关于概率dp的个人理解与总结

最新推荐文章于 2019-08-14 18:00:39 发布
最新推荐文章于 2019-08-14 18:00:39 发布
阅读量805 收藏 1
点赞数
分类专栏： 动态规划 文章标签： dp 概率dp 数学

原文来自：http://blog.csdn.net/wdcjdtc/article/details/38424029

首先，概率dp主要解决的是关于概率问题和期望问题的求解。

难点和普通dp一样在于dp[i][j][k]的维数控制和含义，其实就是转移方程的构建。

然后一般地，求概率是正推、求期望是逆推。（开始的很多状态不可能发生概率为0，最后的状态出口期望为0）

对于求概率当前点的概率是由前面能到达当前点的点乘上到达当前点的概率得到的。

也就是dp[i]=Σ(dp[j]*p[j][i])  i是当前点、j是前面的点。

对于求期望当前点的期望是由当前点所能到达的点得到的。（注意下，对应的概率是当前点到达之后点的概率，因为你要到达后面的点后面的点才能传递给你期望！）

也就是E[i]=Σ((E[j]+k)*p[i][j])  i是当前点、j是当前点所能到达的点，k是所需的期望值。

然后就是对于期望的话，如果成环的话数据范围小的话可以用高斯消元解决（之前的博文提到），如果范围大就要推导公式了（后面的题目有提到）。


poj  2096 Collecint Bugs 

dp求期望入门题。

题意，思路，公式引用别人的：http://www.cnblogs.com/kuangbin/archive/2012/10/02/2710606.html

dp求期望
逆着递推求解
题意：（题意看题目确实比较难道，n和s都要找半天才能找到）
   一个软件有s个子系统，会产生n种bug
   某人一天发现一个bug,这个bug属于一个子系统，属于一个分类
   每个bug属于某个子系统的概率是1/s,属于某种分类的概率是1/n
   问发现n种bug,每个子系统都发现bug的天数的期望。

求解：
         dp[i][j]表示已经找到i种bug,j个系统的bug，达到目标状态的天数的期望
         dp[n][s]=0;要求的答案是dp[0][0];
         dp[i][j]可以转化成以下四种状态:
              dp[i][j],发现一个bug属于已经有的i个分类和j个系统。概率为(i/n)*(j/s);
              dp[i][j+1],发现一个bug属于已有的分类，不属于已有的系统.概率为 (i/n)*(1-j/s);
              dp[i+1][j],发现一个bug属于已有的系统，不属于已有的分类,概率为 (1-i/n)*(j/s);
              dp[i+1][j+1],发现一个bug不属于已有的系统，不属于已有的分类,概率为 (1-i/n)*(1-j/s);
        整理便得到转移方程
代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-5  
  9. using namespace std;  
  10. double dp[1020][1020];  
  11. int main()  
  12. {  
  13.     int n,s;  
  14.     while(cin>>n>>s)  
  15.     {  
  16.         memset(dp,0,sizeof(dp));  
  17.         for(int i=n; i>=0; i--)  
  18.         {  
  19.             for(int j=s; j>=0; j--)  
  20.             {  
  21.                 if(i==n&&j==s) continue;  
  22.                 double tep=1.0;  
  23.                 if(i<n) tep+=(n*1.0-i)*j/(n*s)*dp[i+1][j];  
  24.                 if(j<s) tep+=(s*1.0-j)*i/(n*s)*dp[i][j+1];  
  25.                 if(i<n&&j<s) tep+=(n*1.0-i)*(s*1.0-j)/(n*s)*dp[i+1][j+1];  
  26.                 dp[i][j]=tep/(1-(i*j*1.0)/(s*n));  
  27.             }  
  28.         }  
  29.         printf("%.4f\n",dp[0][0]);  
  30.     }  
  31.     return 0;  
  32. }  


类似的简单题：

hdu 3853     注意停留原地的情况，应该跳过不处理。还有一点走一步的期望是2。
hdu 4405     处理一下连续移动的情况
SGU 495      用概率求期望
CF 148D   考虑下边界就OK了，方程很好推


zoj 3640 Help Me Escape

题意：

一只吸血鬼，有n条路给他走，每次他随机走一条路，

每条路有个限制，如果当时这个吸血鬼的攻击力大于等于某个值，那么就会花费t天逃出去。

否则，花费1天的时间，并且攻击力增加，问他逃出去的期望天数。

思路：

方程很好像  dp[i] 有i点战斗力逃出去的期望

那么如果  x>c[i]时 dp[i]=(1.0/n)*Σt[i]

否则   dp[i]=(1.0/n)*Σ(dp[i+c[i]]+1)

因为很多点会被重复用，所以写成记忆化搜索。

还有一个要注意的，t[i]是向下取整的。

代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-12  
  9. using namespace std;  
  10. #define N 10020  
  11. double dp[N];  
  12. int c[123];  
  13. int t[123];  
  14. int MAX;  
  15. int n,f;  
  16. double dfs(int x)  
  17. {  
  18.     if(x>MAX) x=MAX;  //小优化  超过最大值 就为最大值  
  19.     if(fabs(dp[x]+1)>eps) return dp[x];  
  20.     double tep=0.0;  
  21.     for(int i=1;i<=n;i++)  
  22.     {  
  23.         if(x>c[i]) tep+=1.0/n*t[i];  
  24.         else tep+=1.0/n*(dfs(x+c[i])+1);  
  25.     }  
  26.      return dp[x]=tep;  
  27. }  
  28. int main()  
  29. {  
  30.     while(cin>>n>>f)  
  31.     {  
  32.         int i;  
  33.         MAX=-1;  
  34.         memset(dp,-1,sizeof(dp));  
  35.         for(i=1;i<=n;i++)  
  36.         {  
  37.             scanf("%d",&c[i]);  
  38.             MAX=max(MAX,c[i]+1);  
  39.             t[i]=(int)((1+sqrt(5.0))/2*c[i]*c[i]);  //这里要注意了  t[i]是一个向下取整的！  
  40.         }  
  41.         dp[f]=dfs(f);  
  42.         printf("%.3f\n",dp[f]);  
  43.     }  
  44.     return 0;  
  45. }  


poj 3744 Scout YYF I

其实概率方程很简单，就是有地雷的时候那个点是不能得到其他点的概率要是0.

然后就是分段的思想了，按区间分步求，起点是1，终点MAX+1。

然后需要注意的是：

1、有可能1是雷，你直接爆炸~ bomb :) ~

2、范围很大，需要用矩阵快速幂优化

3、雷不是有序的，要记得排序


代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-12  
  9. using namespace std;  
  10. #define N 10020  
  11. struct matrix  
  12. {  
  13.     double mat[3][3];  
  14. };  
  15. matrix matmul(matrix a,matrix b,int n)  
  16. {  
  17.     int i,j,k;  
  18.     matrix c;  
  19.     memset(c.mat,0,sizeof(c.mat));  
  20.     for(i=0; i<n; i++) for(j=0; j<n; j++) for(k=0; k<n; k++) c.mat[i][j]+=a.mat[i][k]*b.mat[k][j];  
  21.     return c;  
  22. }  
  23. matrix matpow(matrix a,int k,int n)  
  24. {  
  25.     matrix b;  
  26.     int i;  
  27.     memset(b.mat,0,sizeof(b.mat));  
  28.     for(i=0; i<n; i++) b.mat[i][i]=1;  
  29.     while(k)  
  30.     {  
  31.         if(k&1) b=matmul(a,b,n);  
  32.         a=matmul(a,a,n);  
  33.         k>>=1;  
  34.     }  
  35.     return b;  
  36. }  
  37. int main()  
  38. {  
  39.     int n;  
  40.     double p;  
  41.     while(scanf("%d%lf",&n,&p)!=-1)  
  42.     {  
  43.         double q=1-p;  
  44.         int i;  
  45.         int mine[23];  
  46.         for(i=0; i<n; i++)  scanf("%d",&mine[i]);  
  47.         sort(mine,mine+n);  
  48.         int k=0;  
  49.         matrix ans,a,b,c;  
  50.         memset(a.mat,0,sizeof(a.mat));  
  51.         memset(b.mat,0,sizeof(b.mat));  
  52.         memset(c.mat,0,sizeof(c.mat));  
  53.         if(mine[k]==1)  
  54.         {  
  55.             puts("0.0000000");  
  56.             continue;  
  57.         }  
  58.         else if(mine[k]==2)  
  59.         {  
  60.             a.mat[0][0]=0;  
  61.             a.mat[0][1]=1;  
  62.             k++;  
  63.         }  
  64.         else  
  65.         {  
  66.             a.mat[0][0]=p;  
  67.             a.mat[0][1]=1;  
  68.         }  
  69.         int yuan=2;  
  70.         b.mat[0][0]=p;  
  71.         b.mat[1][0]=q;  
  72.         b.mat[0][1]=1;  
  73.         c=b;  
  74.         for(i=k;i<n;i++)  
  75.         {  
  76.             c=b;  
  77.             ans=matmul(a,matpow(c,mine[i]-yuan-1,2),2);  
  78.             a.mat[0][0]=0;  
  79.             a.mat[0][1]=ans.mat[0][0];  
  80.             yuan=mine[i];  
  81.         }  
  82.         ans=matmul(a,matpow(c,mine[n-1]+1-yuan,2),2);  
  83.         printf("%.7f\n",ans.mat[0][0]);  
  84.     }  
  85.     return 0;  
  86. }  

还有几道中等的题目：

poj 2151  dp[i][j][k]第i个人在前j题中做出了k题的概率  最后所有人至少作出一道题的概率减去所有人都做1~N-1题的概率 即为所求
poj 3071  全概率公式  巧妙确定范围的方法

[cpp]  view plain  copy
  1. for(i=0; i<(1<<n); i++) dp[0][i]=1;  
  2. for(i=1; i<=n; i++)  
  3. {  
  4.     for(j=0; j<(1<<n); j++)  
  5.     {  
  6.         int tep=j/(1<<(i-1));  
  7.         tep^=1;  
  8.         int s=tep*(1<<(i-1));  
  9.         int e=tep*(1<<(i-1))+(1<<(i-1));  
  10.         for(k=s; k<e; k++)  
  11.             dp[i][j]+=dp[i-1][j]*dp[i-1][k]*p[j][k];  
  12.     }  
  13. }  

以下几题都比较难了：

hdu 4089 Activation

题意：有n个人排队等着在官网上激活游戏。Tomato排在第m个。
对于队列中的第一个人。有一下情况：
1、激活失败，留在队列中等待下一次激活（概率为p1)
2、失去连接，出队列，然后排在队列的最后（概率为p2）
3、激活成功，离开队列（概率为p3）
4、服务器瘫痪，服务器停止激活，所有人都无法激活了。
求服务器瘫痪时Tomato在队列中的位置<=k的概率

解析：
概率DP；
设dp[i][j]表示i个人排队,Tomato排在第j个位置，达到目标状态的概率(j<=i)
dp[n][m]就是所求
j==1:    dp[i][1]=p1*dp[i][1]+p2*dp[i][i]+p4;
2<=j<=k: dp[i][j]=p1*dp[i][j]+p2*dp[i][j-1]+p3*dp[i-1][j-1]+p4;
k<j<=i:  dp[i][j]=p1*dp[i][j]+p2*dp[i][j-1]+p3*dp[i-1][j-1];
化简：
j==1:    dp[i][1]=p*dp[i][i]+p41;
2<=j<=k: dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1]+p41;
k<j<=i:  dp[i][j]=p*dp[i][j-1]+p31*dp[i-1][j-1];

其中:
p=p2/(1-p1);
p31=p3/(1-p1)
p41=p4/(1-p1)

可以循环i=1->n 递推求解dp[i].在求解dp[i]的时候dp[i-1]就相当于常数了。
在求解dp[i][1~i]时等到下列i个方程
j==1:   dp[i][1]=p*dp[i][i]+c[1];
2<=j<=k:dp[i][j]=p*dp[i][j-1]+c[j];
k<j=i:  dp[i][j]=p*dp[i][j]+c[j];
其中c[j]都是常数了。上述方程可以解出dp[i]了。
首先是迭代得到 dp[i][i].然后再代入就可以得到所有的dp[i]了。

注意特判一种情况。就是p4<eps时候，就不会崩溃了，应该直接输出0

代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-12  
  9. using namespace std;  
  10. double dp[2022][2022];  
  11. int main()  
  12. {  
  13.     int n,m,k;  
  14.     double p1,p2,p3,p4;  
  15.     while(cin>>n>>m>>k>>p1>>p2>>p3>>p4)  
  16.     {  
  17.   
  18.         memset(dp,0,sizeof(dp));  
  19.         int i,j;  
  20.         double p22,p33,p44;  
  21.         p22=p2/(1-p1);  
  22.         p33=p3/(1-p1);  
  23.         p44=p4/(1-p1);  
  24.         if(fabs(p4)<=eps)  
  25.         {  
  26.             puts("0.00000");  
  27.             continue;  
  28.         }  
  29.         dp[1][1]=p44/(1-p22);  
  30.         for(i=2;i<=n;i++)  
  31.         {  
  32.             double p=1.0,tep=0.0;  
  33.             for(j=i;j>=1;j--,p*=p22)       //中间就是迭代求出其中一个，因为五个方程五个未知数，形式相等。  
  34.             {  
  35.                 if(j==1) tep+=p*p44;  
  36.                 else if(j>=2&&j<=k) tep+=p*(p33*dp[i-1][j-1]+p44);  
  37.                 else tep+=p*p33*dp[i-1][j-1];  
  38.             }  
  39.             dp[i][i]=tep/(1-p);  
  40.             for(j=1;j<i;j++)  
  41.             {  
  42.                 if(j==1) dp[i][j]=p22*dp[i][i]+p44;  
  43.                 else if(j>=2&&j<=k) dp[i][j]=p22*dp[i][j-1]+p33*dp[i-1][j-1]+p44;  
  44.                 else dp[i][j]=p22*dp[i][j-1]+p33*dp[i-1][j-1];  
  45.             }  
  46.         }  
  47.         printf("%.5f\n",dp[n][m]);  
  48.   
  49.     }  
  50.     return 0;  
  51. }  



zoj 3329 One Person Game

题意：有三个骰子，分别有k1,k2,k3个面，人物开始分数为零。

每次掷骰子，如果三个面分别是a,b,c的话分数归零，否则分数加上三个骰子的点数和。

分数超过n则游戏结束。求游戏结束的期望掷骰子次数。


思路： 设投出a,b,c 的概率为p0，投出k分的概率为p[k]

则对于每个分数 dp[i]=p0*dp[0]+Σ(dp[i+k]*p[k])+1    ①

又设 dp[i]=A[i]dp[0]+B[i]     ②，则dp[i+k]=A[i+k]dp[0]+B[i+k]

代入① 得：  dp[i]=p0*dp[0]+Σ((A[i+k]dp[0]+B[i+k])*p[k])+1

化简得： dp[i]=(p0+Σ(A[i+k]*p[k]))*dp[0] + Σ(B[i+k]*p[k]) +1

对比②得： A[i]=Σ(A[i+k]*p[k])+p0

                     B[i]=Σ(B[i+k]*p[k]) +1

当i+k>n时A[i+k]=B[i+k]=0
所以dp[0]=B[0] / (1-A[0])可求出

代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-12  
  9. using namespace std;  
  10. int main()  
  11. {  
  12.     int t;  
  13.     cin>>t;  
  14.     while(t--)  
  15.     {  
  16.         int n,k[4],a,b,c;  
  17.         int i,j,l;  
  18.         scanf("%d%d%d%d%d%d%d",&n,&k[1],&k[2],&k[3],&a,&b,&c);  
  19.         double p[22];  
  20.         memset(p,0,sizeof(p));  
  21.         for(i=1;i<=k[1];i++) for(j=1;j<=k[2];j++) for(l=1;l<=k[3];l++) p[i+j+l]+=1.0/(k[1]*k[2]*k[3]);  //求出掷出k点的概率  
  22.         p[a+b+c]-=1.0/(k[1]*k[2]*k[3]);  //单独考虑下分别a,b,c点的情况  
  23.         p[0]=1.0/(k[1]*k[2]*k[3]);  
  24.         double A[600],B[600];  
  25.         memset(A,0,sizeof(A));  
  26.         memset(B,0,sizeof(B));  
  27.         for(i=n;i>=0;i--)           //递推求解  
  28.         {  
  29.             A[i]=p[0];  
  30.             B[i]=1;  
  31.             if(i==n) continue;  
  32.             for(j=1;j<=k[1]+k[2]+k[3];j++)  
  33.             {  
  34.                 A[i]+=p[j]*A[i+j];  
  35.                 B[i]+=p[j]*B[i+j];  
  36.             }  
  37.         }  
  38.         printf("%.15f\n",B[0]/(1-A[0]));  
  39.     }  
  40.     return 0;  
  41. }  

总结下这类概率DP:
既DP[i]可能由DP[i+k]和DP[i+j]需要求的比如DP[0]决定
相当于概率一直递推下去会回到原点 
比如
(1):DP[i]=a*DP[i+k]+b*DP[0]+d*DP[i+j]+c;
但是DP[i+k]和DP[0]都是未知
这时候根据DP[i]的方程式假设一个方程式：
比如:
(2):DP[i]=A[i]*DP[i+k]+B[i]*DP[0]+C[i];
因为要求DP[0],所以当i=0的时候但是A[0],B[0],C[0]未知
对比(1)和(2)的差别 
这时候对比(1)和(2)发现两者之间的差别在于DP[i+j]
所以根据(2)求DP[i+j]然后代入(1)消除然后对比(2)就可以得到A[i],B[i],C[i]
然后视具体情况根据A[i],B[i],C[i]求得A[0],B[0],C[0]继而求DP[0] 

然后下面那题可以好好感受一下这个！


hdu 4035 Maze

经典的概率dp，关于成环的概率dp的求解，公式的推导。

题意，思路，公式引用别人的：http://www.cnblogs.com/kuangbin/archive/2012/10/02/2710606.html

dp求期望的题。
    题意：
    有n个房间，由n-1条隧道连通起来，实际上就形成了一棵树，
    从结点1出发，开始走，在每个结点i都有3种可能：
        1.被杀死，回到结点1处（概率为ki）
        2.找到出口，走出迷宫 （概率为ei）
        3.和该点相连有m条边，随机走一条

    求：走出迷宫所要走的边数的期望值。
    设 E[i]表示在结点i处，要走出迷宫所要走的边数的期望。E[1]即为所求。
    叶子结点：
    E[i] = ki*E[1] + ei*0 + (1-ki-ei)*(E[father[i]] + 1);
         = ki*E[1] + (1-ki-ei)*E[father[i]] + (1-ki-ei);
    非叶子结点：（m为与结点相连的边数）
    E[i] = ki*E[1] + ei*0 + (1-ki-ei)/m*( E[father[i]]+1 + ∑( E[child[i]]+1 ) );
         = ki*E[1] + (1-ki-ei)/m*E[father[i]] + (1-ki-ei)/m*∑(E[child[i]]) + (1-ki-ei);
    设对每个结点：E[i] = Ai*E[1] + Bi*E[father[i]] + Ci;
    对于非叶子结点i，设j为i的孩子结点，则
    ∑(E[child[i]]) = ∑E[j]
                   = ∑(Aj*E[1] + Bj*E[father[j]] + Cj)
                   = ∑(Aj*E[1] + Bj*E[i] + Cj)
    带入上面的式子得
    (1 - (1-ki-ei)/m*∑Bj)*E[i] = (ki+(1-ki-ei)/m*∑Aj)*E[1] + (1-ki-ei)/m*E[father[i]] + (1-ki-ei) + (1-ki-ei)/m*∑Cj;
    由此可得
    Ai =        (ki+(1-ki-ei)/m*∑Aj)   / (1 - (1-ki-ei)/m*∑Bj);
    Bi =        (1-ki-ei)/m            / (1 - (1-ki-ei)/m*∑Bj);
    Ci = ( (1-ki-ei)+(1-ki-ei)/m*∑Cj ) / (1 - (1-ki-ei)/m*∑Bj);
    对于叶子结点
    Ai = ki;
    Bi = 1 - ki - ei;
    Ci = 1 - ki - ei;
    从叶子结点开始，直到算出 A1,B1,C1;
    E[1] = A1*E[1] + B1*0 + C1;
    所以
    E[1] = C1 / (1 - A1);
    若 A1趋近于1则无解...

代码：

[cpp]  view plain  copy
  1. #include"cstdlib"  
  2. #include"cstdio"  
  3. #include"cstring"  
  4. #include"cmath"  
  5. #include"queue"  
  6. #include"algorithm"  
  7. #include"iostream"  
  8. #define eps 1e-12        //注意开1e-8会WA  
  9. #include"vector"  
  10. #define N 10010  
  11. using namespace std;  
  12. struct node  
  13. {  
  14.     int v,w;  
  15.     node(int vv)  
  16.     {  
  17.         v=vv;  
  18.     }  
  19. };  
  20. vector<node>edge[N];  
  21. double A[N],B[N],C[N],Asum[N],Bsum[N],Csum[N];  
  22. double p[N],e[N];  
  23. void dfs(int u,int f)    //最简单的对树的搜索  
  24. {  
  25.     int n=edge[u].size();  
  26.     if(n==1&&u!=1)          //如果是叶子节点  
  27.     {  
  28.         A[u]=Asum[u]=p[u];  
  29.         B[u]=Bsum[u]=1-p[u]-e[u];  
  30.         C[u]=Csum[u]=1-p[u]-e[u];  
  31.         return ;  
  32.     }  
  33.     Asum[u]=Bsum[u]=Csum[u]=0;  
  34.     for(int i=0;i<n;i++)  //不是叶子节点的 按公式求值  
  35.     {  
  36.         if(edge[u][i].v==f) continue;  
  37.         dfs(edge[u][i].v,u);  
  38.         Asum[u]+=A[edge[u][i].v];  
  39.         Bsum[u]+=B[edge[u][i].v];  
  40.         Csum[u]+=C[edge[u][i].v];  
  41.         A[u]=(p[u]+(1-p[u]-e[u])/n*Asum[u])          /(1-(1-p[u]-e[u])/n*Bsum[u]);  
  42.         B[u]=((1-p[u]-e[u])/n)                       /(1-(1-p[u]-e[u])/n*Bsum[u]);  
  43.         C[u]=((1-p[u]-e[u])+(1-p[u]-e[u])/n*Csum[u]) /(1-(1-p[u]-e[u])/n*Bsum[u]);  
  44.     }  
  45.     return ;  
  46. }  
  47. int main()  
  48. {  
  49.     int t,cas=1;  
  50.     cin>>t;  
  51.     while(t--)  
  52.     {  
  53.         int n,i;  
  54.         cin>>n;  
  55.         for(i=0;i<=n;i++)  
  56.             edge[i].clear();  
  57.         for(i=1;i<=n-1;i++)  
  58.         {  
  59.             int a,b;  
  60.             scanf("%d%d",&a,&b);  
  61.             edge[a].push_back(node(b));  
  62.             edge[b].push_back(node(a));  
  63.         }  
  64.         for(i=1;i<=n;i++)     //注意读进来的数是百分比  
  65.         {  
  66.             scanf("%lf%lf",&p[i],&e[i]);  
  67.             p[i]*=0.01;  
  68.             e[i]*=0.01;  
  69.         }  
  70.         dfs(1,1);  
  71.         printf("Case %d: ",cas++);  
  72.         if(fabs(1-A[1])<=eps)       //不断被杀死 逃不出去 T_T  
  73.         {  
  74.             puts("impossible");  
  75.             continue;  
  76.         }  
  77.         printf("%.6f\n",C[1]/(1-A[1]));  
  78.     }  
  79.     return 0;  
  80. }  
神奇豆子
关注
专栏目录
期望/概率dp 学习报告
eliyou的博客
05-01 676
期望/概率dp
概率dp
qq_38890926的博客
08-13 529
概率dp的内容 概率dp研究有关于概率，步数，期望的等问题。 数学期望 P=Σ每一种状态*对应的概率。 因为不可能枚举完所有的状态，有时也不可能枚举完，比如抛硬币，有可能一直是正面，etc。 但是现在发现大多数题就是手动找公式或者DP推出即可，只要处理好边界，然后写好方程，代码超级简短。与常规的求解不同，数学期望经常逆向推出。 比如常规的dp[x]可能表示到了x这一状态有多少，最后答案是d...
概率DP
qq_39951289的博客
10-26 823
概率dp顾名思义就是求一件事件发生的概率。那么和其他的dp有什么区别？没有实际上的区别，只是转移的是概率这一维，而且基本上概率这一位只能装在dp值里面(其他很多dp可以把要的答案放到下标里的)。对于概率dp完全可以把他当做普通的dp，只是有一维固定了罢了。概率dp可以和很多类型挂钩，比如背包，树形，状压等等。 几道例题： 一、HDU 2955 Robberies 如果问的不是概率的话，很简单
算法学习 | 期望dp+概率dp
TTTiko's blog
08-14 695
最近集训的时候学习了概率与组合的内容，恰巧今天又学了概率dp和期望dp，个人觉得超级有意思，比其他dp有趣多了，借机分享一下自己的理解心得。（我才不会告诉你是因为别的dp太难了我学不会呜呜） 概率DP 今天qko学长讲课的时候对概率dp的概括特别到位：“概率dp一般求的是实际的结果。在dp过程中，当前状态是由所有子状态的概率共同转移而来，所以概率dp只是利用了dp的动态而没有规划（即只需转移无需决...
期望与概率DP专题/高斯消元
Qianyri的博客
08-19 1397
高斯消元 总结：概率和期望问题的求解都要依靠递推式，概率问题按照递推式进行dp，期望问题根据递推式化简的难易程度通过化简再dp或高斯消元求解，该类问题大部分仍属于各个类型的dp求解问题 2018.9.3-概率与期望dp学习 Discovering Gold 一排1到n的格子，每个格子上有黄金 ai ,你最开始在 1 号,每一次投骰子决定到哪一个格子，超出1~n范围则重新投掷，你到了哪个格子...
概率DP入门总结 16题
Nicolas
08-12 9213
概率dp小总结 16题
概率dp 树形dp经典题目加解析
04-28
概率dp 树形dp经典题目加解析........高斯求期望...............
DP专题之概率DP
weixin_30273501的博客
07-27 109
注意：在概率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]+d...
概率dp入门
weixin_30588827的博客
10-14 76
/*poj 2096 第一道概率dp看别人的思路，不过总算理解为什么求期望从后往前了 地址：http://blog.csdn.net/morgan_xww/article/details/6774708 */ #include<stdio.h> #include<string.h> #define N 1100 double dp[N][N]; int main(...
dp-概率dp
wximo的专栏
04-22 475
转移方程有时候比较灵活。 一般求概率是正推，求期望是逆推。通过题目可以体会到这点。
动态规划进阶：区间DP、概率DP与树形DP解析
总结来说，区间DP、概率DP和树形DP是动态规划的三个重要分支，分别对应于区间优化、概率计算和树结构问题的求解。理解和掌握这些技术对于解决复杂算法问题至关重要，它们能够帮助我们更有效地处理各种复杂的数据结构...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值