概率与数学期望

例题1：AcWing 217.绿豆蛙的归宿
这题比较简单也比较经典。就是直接通过递归的方式来写期望函数，每次都把子节点到终点的距离当作已知量，然后直接根据定义计算即可，代码如下：

#include<iostream>
#include<cstdio>
using namespace std;
const int N=1e5+5;
int n,m;
int head[N],to[2*N],ne[2*N],w[2*N],idx;
int dout[N];
double f[N];//利用f数组来记忆化搜索
void add(int x,int y,int z){
    ne[++idx]=head[x];
    to[idx]=y;
    w[idx]=z;
    head[x]=idx;
}
void dp(int u){
    if(f[u]>0) return;
    for(int i=head[u];i;i=ne[i]){
        int j=to[i];
        dp(j);
        f[u]=(f[u]+(f[j]+w[i])*1.0/dout[u]);
    }
}
int main(){
    cin>>n>>m;
    while(m--){
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        dout[x]++;
    }
    dp(1);
    printf("%.2lf",f[1]);
    return 0;
}

例题2：AcWing 218.扑克牌
这题的思考方式与上题类似，考虑用记忆化搜索的动态规划来做。每次把未来未知的期望值当作已知量来计算是核心所在。而且这里所存的期望值是指从当前状态到终点所需的代价的期望值，代码如下：

#include<iostream>
#include<cstring>
using namespace std;
const double INF=1e9;
const int N=15;
double f[N][N][N][N][5][5];
int A,B,C,D;
double dp(int a,int b,int c,int d,int x,int y){
    double &v=f[a][b][c][d][x][y];
    if(v>=0) return v;
    int as=a+(x==0)+(y==0);
    int bs=b+(x==1)+(y==1);
    int cs=c+(x==2)+(y==2);
    int ds=d+(x==3)+(y==3);
    int sum=a+b+c+d+(x!=4)+(y!=4);
    if(as>=A && bs>=B && cs>=C && ds>=D) return v=0;
    if(54-sum<=0) return v=INF;
    v=1;
    if(a<13) v+=dp(a+1,b,c,d,x,y)*(13-a)/(54-sum);
    if(b<13) v+=dp(a,b+1,c,d,x,y)*(13-b)/(54-sum);
    if(c<13) v+=dp(a,b,c+1,d,x,y)*(13-c)/(54-sum);
    if(d<13) v+=dp(a,b,c,d+1,x,y)*(13-d)/(54-sum);
    if(x==4){
        double part=INF;
        for(int i=0;i<=3;i++){
            part=min(part,dp(a,b,c,d,i,y));
        }
        v+=(double)part/(54-sum);
    }
    if(y==4){
        double part=INF;
        for(int i=0;i<=3;i++){
            part=min(part,dp(a,b,c,d,x,i));
        }
        v+=(double)part/(54-sum);
    }
    return v;
}
int main(){
    cin>>A>>B>>C>>D;
    memset(f,-1,sizeof f);
    double t=dp(0,0,0,0,4,4);
    if(t>INF/2) t=-1;
    printf("%.3lf",t);
    return 0;
}

例题3：AcWing 216.Rainbow的信号
做位运算的题目，首先想到按位计算，即通过枚举每一位的情况来计算。算期望首先要算概率，考虑抽区间的概率。随机等概率抽取1-n内的两个数，概率显然各为1/n。但是要考虑两个数相同以及可以交换的情况，所以若两数相同就是1/n²，若两数不同则为2/n²。那么接下来只要考虑对于每一个r，有多少个l满足b_l……b_r的位运算和为1（b_i是a_i第k位的值）。and和or的求法较简单，难点在于xor。具体求法见代码：

#include<iostream>
using namespace std;
const int N=1e5+5;
int a[N],last[N][2],b[N];
int f[N];
int main(){
    int n;
    cin>>n;
    for(int i=1;i<=n;i++) cin>>a[i];
    double And=0.0,Or=0.0,Xor=0.0;
    for(int k=0;k<=30;k++){
        for(int i=1;i<=n;i++) b[i]=(a[i]>>k)&1;
        int pos0=0,pos1=0;
        for(int i=1;i<=n;i++){
            last[i][0]=pos0;
            last[i][1]=pos1;
            if(b[i]) pos1=i;
            else pos0=i;
        }
        for(int i=1;i<=n;i++){
            if(b[i]){
                And+=(1<<k)*1.0/n/n;
                Or+=(1<<k)*1.0/n/n;
                Xor+=(1<<k)*1.0/n/n;
                And+=(i-1-last[i][0])*2.0/n/n*(1<<k);
                Or+=(i-1)*2.0/n/n*(1<<k);
                f[i]=i-1-f[i-1]-b[i-1];
                //i-1能用的i都不能用，但是i-1本身可能可以用
            }
            else{
                Or+=last[i][1]*2.0/n/n*(1<<k);
                f[i]=f[i-1]+b[i-1];
                //i-1能用的i也能用，同样考虑i-1自身能否用
            }
            Xor+=f[i]*2.0/n/n*(1<<k);
        }
    }
    printf("%.3lf %.3lf %.3lf",Xor,And,Or);
    return 0;
}

本题的特点是难在求值，而概率是定值，所以其实本质上还是考察位运算的性质