概率dp

https://vjudge.net/contest/264760#problem/B

数学期望,简单的

 

概率从前往后算,期望从后往前算。

https://blog.csdn.net/morgan_xww/article/details/6775853

/**
    dp求期望的题。
    题意:
    有三个均匀的骰子,分别有k1,k2,k3个面,初始分数是0,
    当掷三个骰子的点数分别为a,b,c的时候,分数清零,否则分数加上三个骰子的点数和,
    当分数>n的时候结束。求需要掷骰子的次数的期望。
    题解:
    设 E[i]表示现在分数为i,到结束游戏所要掷骰子的次数的期望值。
    显然 E[>n] = 0; E[0]即为所求答案;
    E[i] = ∑Pk*E[i+k] + P0*E[0] + 1; (Pk表示点数和为k的概率,P0表示分数清零的概率)
    由上式发现每个 E[i]都包含 E[0],而 E[0]又是我们要求的,是个定值。
    设 E[i] = a[i]*E[0] + b[i];
    将其带入上面的式子:
    E[i] = ( ∑Pk*a[i+k] + P0 )*E[0] + ∑Pk*b[i+k] + 1;
    显然,
    a[i] = ∑Pk*a[i+k] + P0;
    b[i] = ∑Pk*b[i+k] + 1;
    当 i > n 时:
    E[i] = a[i]*E[0] + b[i] = 0;
    所以 a[i>n] = b[i>n] = 0;
    可依次算出 a[n],b[n]; a[n-1],b[n-1] ... a[0],b[0];
    则 E[0] = b[0]/(1 - a[0]);
**/
 
#include <cstdio>
#include <cstring>
#include <iostream>
 
using namespace std;
 
int main()
{
    int    nc, n, ks, k1, k2, k3, a, b, c;
    double p0, p[20];
 
    cin >> nc;
    while ( nc-- )
    {
        cin >> n >> k1 >> k2 >> k3 >> a >> b >> c;
        ks = k1 + k2 + k3;
        p0 = 1.0 / (k1*k2*k3);
        memset(p, 0, sizeof(p));
 
        for (int i = 1; i <= k1; i++)
            for (int j = 1; j <= k2; j++)
                for (int k = 1; k <= k3; k++)
                {
                    if ( i != a || j != b || k != c )
                        p[i+j+k] += p0;
                }
 
        double a[520] = {0}, b[520] = {0};
        for (int i = n; i >= 0; i--)
        {
            for (int k = 3; k <= ks; k++)
            {
                a[i] += a[i+k]*p[k];
                b[i] += b[i+k]*p[k];
            }
            a[i] += p0;
            b[i] += 1;
        }
        printf("%.15lf\n", b[0]/(1 - a[0]) );
    }
    return 0;
}

/*
HDU 4035 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]] + ∑(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则无解... */ #include<stdio.h> #include<string.h> #include<algorithm> #include<iostream> #include<math.h> #include<vector> using namespace std; const int MAXN=10010; const double eps=1e-9;//这里1e-8会WA。设为1e-9和1e-10可以 double k[MAXN],e[MAXN]; double A[MAXN],B[MAXN],C[MAXN]; vector<int>vec[MAXN];//存树 bool dfs(int t,int pre)//t的根结点是pre { int m=vec[t].size();//点t的度 A[t]=k[t]; B[t]=(1-k[t]-e[t])/m; C[t]=1-k[t]-e[t]; double tmp=0; for(int i=0;i<m;i++) { int v=vec[t][i]; if(v==pre)continue; if(!dfs(v,t))return false; A[t]+=(1-k[t]-e[t])/m*A[v]; C[t]+=(1-k[t]-e[t])/m*C[v]; tmp+=(1-k[t]-e[t])/m*B[v]; } if(fabs(tmp-1)<eps)return false; A[t]/=(1-tmp); B[t]/=(1-tmp); C[t]/=(1-tmp); /** 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; **/ return true; } int main() { // freopen("in.txt","r",stdin); // freopen("out.txt","w",stdout); int T; int n; int u,v; int iCase=0; scanf("%d",&T); while(T--) { iCase++; scanf("%d",&n); for(int i=1;i<=n;i++)vec[i].clear(); for(int i=1;i<n;i++) { scanf("%d%d",&u,&v); vec[u].push_back(v); vec[v].push_back(u); } for(int i=1;i<=n;i++) { scanf("%lf%lf",&k[i],&e[i]); k[i]/=100; e[i]/=100; } printf("Case %d: ",iCase); if(dfs(1,-1)&&fabs(1-A[1])>eps) { printf("%.6lf\n",C[1]/(1-A[1])); } else printf("impossible\n"); } }

https://cn.vjudge.net/contest/227416#problem/C

 

 

https://cn.vjudge.net/contest/227416#problem/E

 

2的n次方个球队按照竞赛图踢球,给你任意两只球队之间相互赢球的概率,求最后哪支球队最可能夺冠。

分析:

dp[i][j]表示第 i 轮的时候,第 j 支队伍赢的概率。

可得:

对于其中位运算,可以用一个二叉树来更直观的理解  (j>>(i-1))^1) 跟 (k>>(i-1)分别表示一个父节点的两个子节点,(或者写一下二进制数来看)

当(j>>(i-1))^1) == (k>>(i-1)时,表明两个子节点是竞争关系,胜利者将更新到父节点。

相当于枚举。

 

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include <iostream>
using namespace std;
const int maxn=150;
double p[maxn][maxn];
double dp[8][maxn];
int main() {
    int n,i,j,k;
    while(scanf("%d",&n)!=EOF) {
    if(n==-1)
    break;
    for(i=0;i<(1<<n);i++)
    for(j=0;j<(1<<n);j++) {
        scanf("%lf",&p[i][j]);
    }
    for(i=0;i<(1<<n);i++) {
        dp[0][i]=1;
    }
    for(i=1;i<=n;i++)
         for(j=0;j<(1<<n);j++)
         {
             dp[i][j]=0;
             for(k=0;k<(1<<n);k++)
             if(((k>>(i-1))^1)==(j>>(i-1)))//这个判断是否属于同一个子树,直接套用了结论
             dp[i][j]+=dp[i-1][j]*p[j][k]*dp[i-1][k];//与可能比赛的对手进行对决
         }
         double m=0;
         int ans=0;
         for(i=0;i<(1<<n);i++)
         {
             if(m<dp[n][i])
             {
                 m=dp[n][i];
                 ans=i;
              //printf("i==%d\n",i);
             }
         }
        ans++;
        printf("%d\n",ans);
    }
//system("pause");
    return 0;
}

 

 

 

https://www.cnblogs.com/hua-dong/p/8034746.html

题意:

师傅被妖怪抓走了。有n个妖怪,每个妖怪有一个固定的战斗力c[],师傅也有一个初始战斗力f0。每天,师傅会随机选择一个妖怪决斗,如果打得赢ft>c[],就可以逃出去,逃出去要t[]天,毕竟超人不会飞;否则,师傅会不甘心,当天他会拿出秘籍练功,将自己变强,f(t+1)=f(t)+c[],第二天寻找下一次机会。问师傅能够逃脱可怕的妖怪,继续追求去印度吃手抓饼的梦想的天数的数学期望day。

思路:

设dp[F]是战斗力为F时,逃离的天数期望。(答案是dp[f])。则有公式。

dp[F]= Σ 1/n * t[i]              ,F>c[[i]

           +∑ 1/n * dp[F+c[i]]    ,F<=c[i]

经验:

数学期望题目大多数需要逆推。 此处逆推的方式是记忆化。而且此题,F是单增的,而且有很明显的边界,即F达到大于最大的C[]的时候,就不会再向下面搜索了,所以记忆化搜索很有效。实在想不出顺推的DP,就记忆化逆推吧。不然DP烧脑壳

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
const double P=(1.0+sqrt(5.0))/2.0;
const int maxn=200000;
int c[maxn],t[maxn],n,f;double dp[maxn];
double dfs(int F)
{
    if(dp[F]>0) return dp[F];
     for(int i=1;i<=n;i++){
        if(F>c[i]) dp[F]+=1.0*t[i];
        else dp[F]+=dfs(F+c[i])+1.0;
    }
    dp[F]=dp[F]/(1.0*n);return dp[F];
}
int main()
{
    while(~scanf("%d%d",&n,&f)){
       memset(dp,0,sizeof(dp));
       for(int i=1;i<=n;i++){
            scanf("%d",&c[i]);
            t[i]=(int)(1.0*c[i]*c[i]*P);
       }dfs(f);
       printf("%.3lf\n",dp[f]);
   }return 0;
}

 

 

https://www.baidu.com/link?url=uccuIyHpfbFaAy2zqStK2ikOfHS41Nn8HoFmhTNeKfuVlX9ZhZdNz1q5dsKs8-bbDif9tjKxEnFc6NT6Mj-XD5aNUDri9tcmv2dCDhqAU_q&wd=&eqid=b1ca22aa00035a27000000055cb728f3   H题状态压缩一下,然后还有一种min-max容斥做法。

题意:有n种卡片,可以通过买干脆面收集卡片,每包干脆面最多一张卡片,问收集完n种卡片时买的干脆面包数的期望。

 

做法:

把当前手中有的卡片种类状压成s,

然后dp[s],状态为s时的期望。

考虑每次买一包干脆面,有三种情况:

1、已经拥有

2、没有拥有

3、没有卡片

 

于是dp[s]=dp[s]*(1跟3的概率之和)+dp[s|(1<<i)]*p[i] + 1,i为还没有的卡片编号,p[i]为摸到它的概率

#include<map>
#include<string>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<queue>
#include<vector>
#include<iostream>
#include<algorithm>
#include<bitset>
#include<climits>
#include<list>
#include<iomanip>
#include<stack>
#include<set>
using namespace std;
double dp[1<<20],p[20];
int main()
{
    int n;
    while(cin>>n)
    {
        double sum=1;
        for(int i=0;i<n;i++)
        {
            cin>>p[i];
            sum-=p[i];
        }
        dp[(1<<n)-1]=0;
        for(int i=(1<<n)-2;i>-1;i--)
        {
            double s1=0,s2=0;
            for(int j=0;j<n;j++)
                if((i>>j)&1)
                    s1+=p[j];
                else
                    s2+=dp[i|(1<<j)]*p[j];
            dp[i]=(1+s2)/(1-(s1+sum));
        }
        printf("%.4f\n",dp[0]);
    }
}

 

 

https://blog.csdn.net/Mr_Alice/article/details/100187465

题意:

给你一个 n 个点的有向无环图,保证只有点 1 的入度为 0,点 n 的出度为 0。现在有人从点 1 出发,它能等概率的走到它能走到的下一个点或者停留一天,即有 k个出度时,停下和走任意一条路的概率都为 1/(k+1) ,每一天的消耗为已经经过的天数(包括当天),问你走到点 n的期望消耗为多少。下面代码是记忆化搜索的做法。还可以反向建图,按拓扑序来算结果。

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int t, n, m;
vector<int> g[N];
double dp[N], cost[N];
int vis[N];
void dfs(int u) {
    vis[u] = 1;
    double sum1 = 0.0, sum2 = 0.0;
    int len = g[u].size();
    if(len == 0) dp[u] = 0.0, cost[u] = 0.0;
    else {
        for(int i = 0; i < len; i++) {
            int v = g[u][i];
            if(!vis[v]) dfs(v);
            sum1 += dp[v];
            sum2 += cost[v];
        }
        dp[u] = (sum1 + len + 1.0) / len;
        cost[u] = (sum2 + dp[u] * (len + 1)) / len;
    }
//    printf("%d %f %f\n", u, sum1, sum2);
}

int main() {
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        memset(vis, 0, sizeof(vis));
        for(int i = 1; i <= n; i++) g[i].clear();
        int u, v;
        for(int i = 1; i <= m; i++) {
            scanf("%d%d", &u, &v);
            g[u].push_back(v);
        }
        dfs(1);
        printf("%.2f\n", cost[1]);
    }
    return 0;
}

 

posted @ 2019-04-16 18:20  downrainsun  阅读(206)  评论(0编辑  收藏  举报