概率dp集合

bzoj1076

你正在玩你最喜欢的电子游戏，并且刚刚进入一个奖励关。在这个奖励关里，系统将依次随机抛出k次宝物，
每次你都可以选择吃或者不吃（必须在抛出下一个宝物之前做出选择，且现在决定不吃的宝物以后也不能再吃）。
 宝物一共有n种，系统每次抛出这n种宝物的概率都相同且相互独立。也就是说，即使前k-1次系统都抛出宝物1（
这种情况是有可能出现的，尽管概率非常小），第k次抛出各个宝物的概率依然均为1/n。 获取第i种宝物将得到Pi
分，但并不是每种宝物都是可以随意获取的。第i种宝物有一个前提宝物集合Si。只有当Si中所有宝物都至少吃过
一次，才能吃第i种宝物（如果系统抛出了一个目前不能吃的宝物，相当于白白的损失了一次机会）。注意，Pi可
以是负数，但如果它是很多高分宝物的前提，损失短期利益而吃掉这个负分宝物将获得更大的长期利益。 假设你
采取最优策略，平均情况你一共能在奖励关得到多少分值？

题解：套了概率的记忆化搜索；

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cstdlib>
 #include<cmath>
 #include<ctime>
 #include<algorithm>
 #include<iomanip>
 using namespace std;
 #define LL long long
 #define up(i,j,n) for(int i=(j);i<=(n);i++)
 #define FILE "dealing"
 int read(){
     int f=,x=,ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<='')x=(x<<)+(x<<)+ch-'',ch=getchar();
     return f*x;
 }
 const int maxn=;
 const double eps=0.0000001;
 int k,n;
 double v[maxn];//分数
 int d[maxn][maxn],cnt[maxn];//前提集合
 double f[][];
 inline bool cmp(double x,double y){return abs(x-y)<=eps;}
 double dfs(int pos,int S){
     if(pos==)return f[pos][S]=;
     if(!cmp(f[pos][S],-))return f[pos][S];
     f[pos][S]=;
     up(i,,n){
         bool flag=;
         up(j,,cnt[i])if(!(S&(<<d[i][j]-)))flag=;
         if(flag)f[pos][S]+=max(dfs(pos-,S|(<<i-))+v[i],dfs(pos-,S));
         else f[pos][S]+=dfs(pos-,S);
     }
     f[pos][S]/=(n*1.0);
     return f[pos][S];
 }
 int main(){
     freopen(FILE".in","r",stdin);
     freopen(FILE".out","w",stdout);
     k=read(),n=read();
     up(i,,n){
         v[i]=read();int x=read();
         while(x){
             d[i][++cnt[i]]=x;
             x=read();
         }
     }
     up(i,,k)up(j,,(<<n)-)f[i][j]=-;
     printf("%.6lf\n",dfs(k,));
     return ;
 }

bzoj1415

这题题目描述我感觉有问题；

标解是按每次聪聪都走两步算的，而我认为聪聪可能只走一步；

其他的就按普通的概率dp计算即可；

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cstdlib>
 #include<cmath>
 #include<ctime>
 #include<algorithm>
 #include<iomanip>
 using namespace std;
 #define LL long long
 #define up(i,j,n) for(int i=(j);i<=(n);i++)
 #define FILE "dealing"
 int read(){
     int f=,x=,ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<='')x=(x<<)+(x<<)+ch-'',ch=getchar();
     return f*x;
 }
 const int maxn=;
 const double eps=0.0000001;
 int n,m,sx,sy;
 struct node{
     int y,next;
 }e[maxn<<];
 int linkk[maxn],len=;
 void insert(int x,int y){
     e[++len].y=y;
     e[len].next=linkk[x];
     linkk[x]=len;
 }
 int q[maxn<<],head,tail;
 int next[maxn][maxn],d[maxn];
 void bfs(int s){
     head=tail=;
     memset(next[s],,sizeof(next[s]));
     memset(d,,sizeof(d));
     q[++tail]=s;int x;
     next[s][s]=;d[s]=;
     while(++head<=tail){
         x=q[head];
         for(int i=linkk[x];i;i=e[i].next){
             if(!d[e[i].y])next[s][e[i].y]=x,d[e[i].y]=d[x]+,q[++tail]=e[i].y;
             if(d[e[i].y]>d[x]&&next[s][e[i].y]>x)next[s][e[i].y]=x;
         }
     }
 }
 double f[maxn][maxn];
 double dfs(int x,int y){
     if(x==y)return ;
     if(f[x][y]!=-)return f[x][y];
     if(next[x][y]==x||next[x][next[x][y]]==x)return f[x][y]=;
     int sum=;
     f[x][y]=;
     for(int i=linkk[x];i;i=e[i].next)
         sum++,f[x][y]+=dfs(e[i].y,next[x][next[x][y]]);
     f[x][y]+=dfs(x,next[x][next[x][y]]);
     f[x][y]=f[x][y]/sum+;
     return f[x][y];
 }
 int main(){
     freopen(FILE".in","r",stdin);
     freopen(FILE".out","w",stdout);
     n=read(),m=read(),sx=read(),sy=read();
     up(i,,m){
         int x=read(),y=read();
         insert(x,y),insert(y,x);
     }
     up(i,,n)bfs(i);
     up(i,,n)up(j,,n)f[i][j]=-;
     printf("%.3lf\n",dfs(sy,sx));
     return ;
 }

bzoj1426收集邮票

有n种不同的邮票，皮皮想收集所有种类的邮票。唯一的收集方法是到同学凡凡那里购买，每次只能买一张，并且买到的邮票究竟是n种邮票中的哪一种是等概率的，概率均为1/n。但是由于凡凡也很喜欢邮票，所以皮皮购买第k张邮票需要支付k元钱。 现在皮皮手中没有邮票，皮皮想知道自己得到所有种类的邮票需要花费的钱数目的期望。

这题还是很神奇的；

设f[i]表示已经有了i张邮票还需要花费f[i]单位的钱买全所有邮票；

设g[i]表示买了i张邮票还需要买g[i]张邮票才能买全邮票；

g[i]很好求，买第i张邮票成功的概率(n-i)/n，第i张邮票买n/(n-i)次，然后累加就可以了；

怎么处理钱数？我们不如先给钱数多的钱，也就是说在期望再买k次就能买全的时候，买这一张用k元，之后递减，可以证明这两种付款等价；

也可以视为这张票是1元买的，而后面的每张票都贵了1元；

于是有了递推式子：

f[i]=(n-i)/n*(f[i+1]+g[i+1]+1)+i/n*(g[i]+f[i]+1)

经过转化，有了这个式子

f[i]=f[i+1]+g[i+1]+i/(n-i)*g[i]+n/(n-i)

递推即可；

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cstdlib>
 #include<cmath>
 #include<ctime>
 #include<algorithm>
 #include<iomanip>
 using namespace std;
 #define LL long long
 #define up(i,j,n) for(int i=(j);i<=(n);i++)
 #define FILE "dealing"
 int read(){
     int f=,x=,ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<='')x=(x<<)+(x<<)+ch-'',ch=getchar();
     return f*x;
 }
 const int maxn=;
 const double eps=0.0000001;
 int n;
 double g[maxn],f[maxn];
 double dfs(int i){
     if(i==n)return ;
     return dfs(i+)+g[i+]+i*1.0/(n-i)*g[i]+n*1.0/(n-i);
 }
 int main(){
     freopen(FILE".in","r",stdin);
     freopen(FILE".out","w",stdout);
     n=read();
     for(int i=n-;i>=;i--)g[i]=g[i+]+n*1.0/(n-i);
     printf("%.2lf\n",dfs());
     return ;
 }

bzoj4008: [HNOI2015]亚瑟王

小 K 不慎被 LL 邪教洗脑了，洗脑程度深到他甚至想要从亚瑟王邪教中脱坑。

他决定，在脱坑之前，最后再来打一盘亚瑟王。既然是最后一战，就一定要打得漂

亮。众所周知，亚瑟王是一个看脸的游戏，技能的发动都是看概率的。作为一个非

洲人，同时作为一个前 OIer，小 K 自然是希望最大化造成伤害的期望值。但他已

经多年没写过代码，连 Spaly都敲不对了，因此，希望你能帮帮小 K，让他感受一

下当欧洲人是怎样的体验。 

本题中我们将考虑游戏的一个简化版模型。 

玩家有一套卡牌，共 n张。游戏时，玩家将 n 张卡牌排列成某种顺序，排列后

将卡牌按从前往后依次编号为 1 ~  n。本题中，顺序已经确定，即为输入的顺序。

每张卡牌都有一个技能。第 i 张卡牌的技能发动概率为 pi，如果成功发动，则会对

敌方造成di点伤害。也只有通过发动技能，卡牌才能对敌方造成伤害。基于现实因

素以及小K非洲血统的考虑，pi不会为 0，也不会为 1，即 0 < pi < 1。 

一局游戏一共有 r 轮。在每一轮中，系统将从第一张卡牌开始，按照顺序依次

考虑每张卡牌。在一轮中，对于依次考虑的每一张卡牌： 

1如果这张卡牌在这一局游戏中已经发动过技能，则 

1.1 如果这张卡牌不是最后一张，则跳过之（考虑下一张卡牌）； 

否则（是最后一张），结束这一轮游戏。 

2否则（这张卡牌在这一局游戏中没有发动过技能），设这张卡牌为第 i 张 

2.1将其以 pi的概率发动技能。 

2.2如果技能发动，则对敌方造成 di点伤害，并结束这一轮。 

2.3如果这张卡牌已经是最后一张（即 i 等于n），则结束这一轮；否则，

考虑下一张卡牌。 

请帮助小 K 求出这一套卡牌在一局游戏中能造成的伤害的期望值。 

 

 

解法很经典，几乎是对付这一类题目的通解；

推导：

要求ans，必须知道卡牌i打出的概率g[i]

卡牌打出的顺序不好搞，干脆设g[i]为卡牌i没打出的概率，上面再换成1-g[i]即可；

怎么算卡牌i没打出的概率g[i]？

不好算啊，想想怎么分类吧？

分析之后想到可以这样分类（我没想到，别人想到了），g[i]=  f[i-1][j]*(1-p[i])^(r-j)

可以分为它在所有轮中它前面有0个，1个，2个...打出它没打出的概率之和；

f[i][j]可以递推：

f[i][j]=f[i-1][j]*(1-p[i])^(n-j)+f[i-1][j-1]*(1-(1-p[i])^(n-j+1))

然后万事大吉了;

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<string>
 #include<cstdlib>
 #include<cmath>
 #include<ctime>
 #include<algorithm>
 #include<iomanip>
 using namespace std;
 #define LL long long
 #define up(i,j,n) for(int i=(j);i<=(n);i++)
 #define FILE "dealing"
 int read(){
     int f=,x=,ch=getchar();
     while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
     while(ch>=''&&ch<='')x=(x<<)+(x<<)+ch-'',ch=getchar();
     return f*x;
 }
 const int maxn=;
 const double eps=0.0000001;
 int T,n,r;
 double d[],p[],f[][],g[];
 double mi(double a,int b){
     double ans=;
     while(b){
         if(b%)ans*=a;
         b/=;
         a*=a;
     }
     return ans;
 }
 int main(){
     freopen(FILE".in","r",stdin);
     freopen(FILE".out","w",stdout);
     T=read();
     while(T--){
         n=read(),r=read();
         up(i,,n)scanf("%lf%lf",&p[i],&d[i]);
         memset(f,,sizeof(f));
         memset(g,,sizeof(g));
         f[][]=;
         up(i,,n)up(j,,min(i,r)){
             f[i][j]=f[i-][j]*mi(-p[i],r-j)+((j->=)?(f[i-][j-]*(-mi(-p[i],r-j+))):());
         }
         up(i,,n)up(j,,i-)g[i]+=f[i-][j]*mi(-p[i],r-j);
         double ans=;
         up(i,,n)ans+=(-g[i])*d[i];
         printf("%.10lf\n",ans);
     }
     return ;
 }