DP专题之概率DP

最新推荐文章于 2024-09-07 22:39:09 发布

weixin_30273501

最新推荐文章于 2024-09-07 22:39:09 发布

阅读量119

点赞数

文章标签： php 数据结构与算法

原文链接：http://www.cnblogs.com/wolf940509/p/6617115.html

版权

注意：在概率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;
}

转载于:https://www.cnblogs.com/wolf940509/p/6617115.html