DP专题之概率DP

注意：在概率DP中求期望要逆着推，求概率要正着推

概率DP求期望：

链接： http://acm.hdu.edu.cn/showproblem.php?pid=4405

dp[ i ]表示从i点走到n点的期望，在正常情况下i点可以到走到i+1,i+2,i+3,i+4,i+5,i+6 点且每个点的概率都为1/6

所以dp[i]=(dp[i+1]+dp[i+2]+dp[i+3]+dp[i+4]+dp[i+5]+dp[i+6])/6 + 1（步数加一）

而对于有跳跃的点直接为dp[a]=dp[b];

</pre><pre code_snippet_id="436469" snippet_file_name="blog_20140727_1_1601949" name="code" class="cpp">

#include<iostream>

#include<cstdio>

#include<cstring>

using namespace std;

const int maxn=100000+10;

double dp[maxn];

int vist[maxn];

int main()

{

    int n,m;

    while(cin>>n>>m)

    {

        if(n==0&&m==0)

        break;

        memset(vist,-1,sizeof(vist));

        memset(dp,0.0,sizeof(dp));

        int a,b;

        while(m--)

        {

            cin>>a>>b;

            vist[a]=b;

        }

        for(int i=n-1;i>=0;i--)

        {

            if(vist[i]!=-1)   dp[i]=dp[vist[i]];

            else

            {

                dp[i]=(dp[i+1]+dp[i+2]+dp[i+3]+dp[i+4]+dp[i+5]+dp[i+6])/6.0+1;

            }

        }

        printf("%.4lf\n",dp[0]);

    }

    return 0;

}

直接推到公式求期望：

链接：http://acm.hdu.edu.cn/showproblem.php?pid=3853

题目大意

有一个人被困在一个 R*C(2<=R,C<=1000) 的迷宫中，起初他在 (1,1) 这个点，迷宫的出口是 (R,C)。在迷宫的每一个格子中，他能花费 2 个魔法值开启传送通道。假设他在
(x,y) 这个格子中，开启传送通道之后，有 p_lift[i][j] 的概率被送到 (x,y+1)，有 p_down[i][j] 的概率被送到 (x+1,y)，有 p_loop[i][j] 的概率被送到 (x,y)。问他到出口需要花费的魔法值的期望是多少。

做法分析

令：f[i][j] 表示从 (i,j) 这个点到出口 (R,C) 花费的魔法值的期望。

那么，我们有：

f[i][j] = p_loop[i][j]*f[i][j] + p_left[i][j]*f[i][j+1] + p_down[i][j]*f[i+1][j]

移项可得：

(1-p_loop[i][j])*f[i][j] = p_left[i][j](f[i][j+1] + p_down[i][j]*f[i+1][j]

于是我们可以倒着递推了

#include<iostream>

#include<cstdio>

#include<cstring>

using namespace std;

const int maxn=1000+10;

double dp[maxn][maxn];

typedef struct Mat

{

    double a,b,c;

};

Mat p[maxn][maxn];

int main()

{

    int r,c;

    while(scanf("%d%d",&r,&c)!=EOF)

    {

        if(r==0&&c==0)  break;

        for(int i=0;i<r;i++)

            for(int j=0;j<c;j++)

            scanf("%lf%lf%lf",&p[i][j].a,&p[i][j].b,&p[i][j].c);

        memset(dp,0.0,sizeof(dp));

        for(int i=r-1;i>=0;i--)

            for(int j=c-1;j>=0;j--)

        {

            if(i==r-1&&j==c-1)   continue;

            if(1-p[i][j].a==0)   continue;

            dp[i][j]=(1+dp[i][j+1]*p[i][j].b+dp[i+1][j]*p[i][j].c)/(1.0-p[i][j].a);

        }

        printf("%.3lf\n",2*dp[0][0]);

    }

    return 0;

}

直接推倒公式求期望

链接：http://poj.org/problem?id=2096

dp求期望的题。
题意：一个软件有s个子系统，会产生n种bug。
某人一天发现一个bug，这个bug属于某种bug，发生在某个子系统中。
求找到所有的n种bug，且每个子系统都找到bug，这样所要的天数的期望。
需要注意的是：bug的数量是无穷大的，所以发现一个bug，出现在某个子系统的概率是1/s，
属于某种类型的概率是1/n。
解法：
dp[i][j]表示已经找到i种bug，并存在于j个子系统中，要达到目标状态的天数的期望。
显然，dp[n][s]=0，因为已经达到目标了。而dp[0][0]就是我们要求的答案。
dp[i][j]状态可以转化成以下四种：
dp[i][j] 发现一个bug属于已经找到的i种bug和j个子系统中
dp[i+1][j] 发现一个bug属于新的一种bug，但属于已经找到的j种子系统
dp[i][j+1] 发现一个bug属于已经找到的i种bug，但属于新的子系统
dp[i+1][j+1]发现一个bug属于新的一种bug和新的一个子系统
以上四种的概率分别为：
p1 = i*j / (n*s)
p2 = (n-i)*j / (n*s)
p3 = i*(s-j) / (n*s)
p4 = (n-i)*(s-j) / (n*s)
又有：期望可以分解成多个子期望的加权和，权为子期望发生的概率，即 E(aA+bB+...) = aE(A) + bE(B) +...
所以：
dp[i,j] = p1*dp[i,j] + p2*dp[i+1,j] + p3*dp[i,j+1] + p4*dp[i+1,j+1] + 1;
整理得：
dp[i,j] = ( 1 + p2*dp[i+1,j] + p3*dp[i,j+1] + p4*dp[i+1,j+1] )/( 1-p1 )
= ( n*s + (n-i)*j*dp[i+1,j] + i*(s-j)*dp[i,j+1] + (n-i)*(s-j)*dp[i+1,j+1] )/( n*s - i*j )

#include<iostream>

#include<cstdio>

#include<cstring>

using namespace std;

const int maxn=1000+10;

double dp[maxn][maxn];

int main()

{

    int n,s;

    cin>>n>>s;

    dp[n][s]=0.0;

    for(int i=n;i>=0;i--)

        for(int j=s;j>=0;j--)

    {

        if(i==n&&j==s)   continue;

        dp[i][j]=(n*s+(n-i)*j*dp[i+1][j]+i*(s-j)*dp[i][j+1]+(s-j)*(n-i)*dp[i+1][j+1])/(n*s-i*j);

    }

    printf("%.4lf\n",dp[0][0]);

    return 0;

}

先求概率在通过概率从求期望类型

链接：http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=2422

题解：《算法竞赛入门经典训练指南》141～142

#include<iostream>

#include<cstdio>

#include<cstring>

#include<cmath>

using namespace std;

const int maxn=110;

double dp[maxn][maxn];

int main()

{

    int t;

    scanf("%d",&t);

    for(int cas=1;cas<=t;cas++)

    {

        int a,b,n;

        scanf("%d/%d%d",&a,&b,&n);

        double p=(double)a/b;

        memset(dp,0.0,sizeof(dp));

        dp[0][0]=1.0;

        dp[0][1]=0.0;

        for(int i=1;i<=n;i++)

            for(int j=0;b*j<=a*i;j++)

        {

            dp[i][j]=dp[i-1][j]*(1-p);

            if(j)  dp[i][j]+=dp[i-1][j-1]*p;

        }

        double Q=0.0;

        for(int i=0;b*i<=a*n;i++)

            Q+=dp[n][i];

        printf("Case #%d: %d\n",cas,(int)(1/Q));

    }

    return 0;

}