cf期望概率专题

cf1009E：求到第i段期望和的比较困难，但是单独求每段的期望是比较容易的，所以单独对每段求和，然后累计总和

E[i]=1/2*a1+1/4*a2+...+1/2^(i-1)*ai-1+1/2^(i-1)*ai，E[1-n]是可以递推的

#include<bits/stdc++.h>
using namespace std;
#define ll long long

const int maxn = 1e6+;
const ll mod = ;

int n;
ll a[maxn],dp[maxn],P[maxn];

int main(){
    cin>>n;
    for(int i=;i<=n;i++)scanf("%lld",&a[i]);
    P[]=;
    for(int i=;i<=n;i++)P[i]=P[i-]*%mod;

    dp[]=a[]*P[n-]%mod;
    for(int i=;i<=n;i++){
        dp[i]=((dp[i-]-a[i-]*P[n-i]%mod)%mod+mod)%mod;
        dp[i]=(dp[i]+a[i]*P[n-i]%mod)%mod;
    }

    ll ans=;
    for(int i=;i<=n;i++)
        ans=(ans+dp[i])%mod;
    cout<<ans<<'\n';
}

cf168b：概率+背包dp，每件物品有获得概率p，有的物品会消耗掉一格体积，有的物品可以扩容，问得到l个物品并且都装下的概率

dp[i][j][l]表示前i个物品，得到j个，剩下容量为l的概率，转移方程：dp[i][j][k]=pi*dp[i-1][j-1][k-ai]+(1-pi)dp[i-1][j][k]

因为是无序的，所以背包偏移+200来保证第三维下标为正，注意要从当前状态推导到下一状态

#include<bits/stdc++.h>
using namespace std;
#define N 205
double dp[N][N][N<<];
int n,L,k,a[N];
double p[N];
int main(){
    cin>>n>>L>>k;
    for(int i=;i<=n;i++)cin>>p[i],p[i]*=0.01;
    for(int i=;i<=n;i++)cin>>a[i];

    dp[][][+k]=;
    for(int i=;i<=n;i++){
        for(int j=;j<=i;j++)
            for(int l=;l<=;l++){
                dp[i][j][l]+=(-p[i])*dp[i-][j][l];//没赢
                if(a[i]==-){//是奖品
                    if(l)dp[i][j+][l-]+=p[i]*dp[i-][j][l];
                }
                else {//是背包
                    dp[i][j+][min(l+a[i],)]+=p[i]*dp[i-][j][l];
                }
            }
    }

    double ans=;
    for(int j=L;j<=n;j++)
        for(int l=;l<=;l++)
            ans+=dp[n][j][l];
    printf("%.10lf\n",ans);
}

cf513C——细节题：枚举拍卖价格i，用长度为n的二进制位，1表示第j个人出价>=i

n个里起码选两个1 ，这时有两种情况 1：一个选择>i,剩下的选的=i的概率，2：都选i的概率

每种状态的12情况的概率叠加，i的所有状态概率叠加就是价格为i时的概率

/*
枚举拍卖价格i
用长度为n的二进制位，1表示第j个人出价>=i,0反之
    n个里起码选两个1
        1：一个选择>i,剩下的选的=i的概率
        2：都选i的概率
    每种状态的12情况的概率叠加
所有状态概率叠加就是价格为i时的概率
*/
#include<bits/stdc++.h>
using namespace std;
#define N 10005
int n,L[],R[];
double ans[N];
int count(int x){
    int res=;
    for(int i=;i<n;i++)
        if(x>>i & )res++;
    return res;
}
int main(){
    cin>>n;
    for(int i=;i<n;i++)cin>>L[i]>>R[i];
    for(int i=;i<=;i++){
        for(int S=;S<(<<n);S++)if(count(S)>=){
            double pp1=;
            for(int j=;j<n;j++)if(S>>j & ){//情况1，枚举第j个作为>i的选项
                double p1=;
                if(L[j]>i)p1=;
                else if(R[j]<=i)p1=;
                else if(R[j]>i && L[j]<=i)p1*=1.0*(R[j]-i)/(R[j]-L[j]+);

                for(int k=;k<n;k++)if(k!=j){
                    if(S>>k & ){
                        if(R[k]<i || L[k]>i)p1=;
                        else p1*=1.0/(R[k]-L[k]+);
                    }
                    else {
                        if(L[k]>=i)p1=;
                        else if(R[k]<i)p1*=;
                        else if(L[k]<i && R[k]>=i)p1*=1.0*(i-L[k])/(R[k]-L[k]+);
                    }
                }

                pp1+=p1;
            }

            double p2=;//情况2，都选i
            for(int j=;j<n;j++){
                if(S>>j & ){//第j人等于i
                    if(L[j]>i || R[j]<i)p2=;
                    p2*=1.0/(R[j]-L[j]+);
                }
                else {//第j人小于i
                    if(R[j]<i)p2*=;
                    else if(L[j]>=i)p2=;
                    else if(L[j]<i && R[j]>=i)p2*=1.0*(i-L[j])/(R[j]-L[j]+);
                }
            }

            ans[i]+=pp1+p2;
        }
    }
    double sum=;
    for(int i=;i<=;i++)
        sum+=ans[i]*i;
    printf("%.10lf\n",sum);
} 

cf846F——期望线性性

由期望的线性可加性，每个ai的贡献可以单独计算，每个ai的贡献当且仅当其作为区间[L,R]第一个出现的值
设ai上一次出现的位置是L[ai], 那么ai有贡献的区间总共有2*(i-L[ai])*(n-i+1)-1
用序列自动机往前跳

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1000005
int n,a[N],L[N],pos[N];
double ans;
int main(){
    cin>>n;
    for(int i=;i<=n;i++)cin>>a[i];
    for(int i=;i<=n;i++){
        L[i]=pos[a[i]];
        pos[a[i]]=i;
    }
    for(int i=;i<=n;i++)
        if(L[i]==i) ans+=*(n-i+)-;
        else ans+=2ll*(i-L[i])*(n-i+)-;
    ans/=1ll*n*n;
    printf("%.10lf\n",ans);
}

cf109b——求概率转化为 统计所有合法情况个数/所有情况个数

1. 先把所有lucky数打表，排序后存在数组里
2. 一段区间内恰好有k个数，那么这k个数必定是连续的，我们枚举枚举这一段连续的的左右下标i,j可以得到两个取值区间
3. 左边界 [v[i-1]+1,v[i]] 右边界[v[j],v[j+1]-1]，然后这两个边界再和[pl,pr],[vl,vr]求交，求有多少可能的取值
4. 求出对于每个i,j的合法边界个数，然后统计求和就可以

#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll a[],cnt,pl,pr,vl,vr,k;
void dfs(ll num){
    if(num>=1e9)return;
    if(num)a[++cnt]=num;
    dfs(num*+);dfs(num*+);
}
ll jiao(ll L1,ll R1,ll L2,ll R2){//求区间交的长度
    if(R1<L2 || R2<L1)return ;//不相交
    ll L=max(L1,L2),R=min(R1,R2);
    return R-L+;
}
int main(){
    dfs();
    cin>>pl>>pr>>vl>>vr>>k;
    sort(a+,a++cnt);
    a[cnt+]=1e9;

    ll ans=;
    for(int i=;i+k-<=cnt;i++){
        int j=i+k-;
        ll tmp1=jiao(pl,pr,a[i-]+,a[i]);
        ll tmp2=jiao(vl,vr,a[j],a[j+]-);
        ll tmp3=jiao(vl,vr,a[i-]+,a[i]);
        ll tmp4=jiao(pl,pr,a[j],a[j+]-);
        if(k==){//特判处理
            ans+=tmp1*tmp2+tmp3*tmp4;
            ll tmp5=jiao(pl,pr,a[i],a[i]);
            ll tmp6=jiao(vl,vr,a[i],a[i]);
            if(tmp5 && tmp6)ans--;//(a[i],a[i]这种情况算了两次)
        }
        else
            ans+=tmp1*tmp2+tmp3*tmp4;
    }
    printf("%.10lf\n",1.0*ans/((pr-pl+)*(vr-vl+)));
}

cf54C——求概率转化为 统计所有合法情况个数/所有情况个数

问题：n个数，每个数的取值范围是[Li,Ri], 那么 k%的数第一个数为1的概率是多少

思路：先求出每个数取到首位为1的概率，然后用背包dp[i][j]表示前i个数有j个首位为1的概率

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define N 1005
ll n,L[N],R[N],K,k;
double p[N],dp[N][N];

ll jiao(ll L1,ll R1,ll L2,ll R2){
/*    cout<<R1-L2<<" ";
    cout<<R2-L1<<"\n";
*/    if(R1<L2 || R2<L1) return ;
    ll L=max(L1,L2),R=min(R1,R2);
    return R-L+;
}
double calc(ll low,ll up){
    ll sum=;
    for(ll p=;p<=1e18;p*=){
        sum+=jiao(p,p*-,low,up);
        if(p==1e18)break;
    }
    return 1.0*sum/(up-low+);
}

int main(){
    cin>>n;
    for(int i=;i<=n;i++){
        cin>>L[i]>>R[i];
        p[i]=calc(L[i],R[i]);
    }
    cin>>K;
    k=(n*K)/;
    if(n*K%!=)
        k++;

    dp[][]=;
    for(int i=;i<=n;i++)
        for(int j=;j<=n;j++){
            dp[i][j]+=(-p[i])*dp[i-][j];
            if(j)
                dp[i][j]+=p[i]*dp[i-][j-];
        }
    double ans=;
    for(int i=k;i<=n;i++)
        ans+=dp[n][i];
    printf("%.10lf\n",ans);
} 

CF540D——概率递推dp(倒序dp或记忆化搜索)

用r个石头，s个剪刀，p个布，两个不同的相遇会减掉输的那个，相同的相遇则会不变
问最后只剩下石头，只剩下剪刀，只剩下布的概率
dp[i][j][k]表示剩下i个石头，j个剪刀，k个布的概率
因为本题初始状态是dp[r][s][p]=1，目标状态是dp[0][0][0],所以沿着这个状态从后往前推导就行
最后求出dp[1-r][0][0]就是石头的答案，其它同理

#include<bits/stdc++.h>
using namespace std;
#define N 105
int r,s,p;
double dp[N][N][N];
int main(){
    cin>>r>>s>>p;
    dp[r][s][p]=;
    for(int i=r;i>=;i--)
        for(int j=s;j>=;j--)
            for(int k=p;k>=;k--){
                if(i==r && j==s && k==p)continue;
                int base=(i+j+k+)*(i+j+k+);
                if(i+<=r && (j!=||k!=))dp[i][j][k]+=2.0*(i+)*k/(base-(i+)*(i+)-j*j-k*k)*dp[i+][j][k];
                if(j+<=s && (i!=||k!=))dp[i][j][k]+=2.0*(j+)*i/(base-i*i-(j+)*(j+)-k*k)*dp[i][j+][k];
                if(k+<=p && (i!=||j!=))dp[i][j][k]+=2.0*(k+)*j/(base-i*i-j*j-(k+)*(k+))*dp[i][j][k+];
            }
    double ans1=,ans2=,ans3=;
    for(int i=;i<=r;i++)ans1+=dp[i][][];
    for(int j=;j<=s;j++)ans2+=dp[][j][];
    for(int k=;k<=p;k++)ans3+=dp[][][k];
    printf("%.10lf %.10lf %.10lf\n",ans1,ans2,ans3);
} 

cf351b——期望递推dp

给定一个初始排列{n},AB两个人轮流操作
A选择一个相邻的对交换位置
B 0.5概率随机交换一个相邻的逆序对，0.5几率随机交换一个相邻的顺序对，如果没有则不交换
当排列为递增排列时结束操作，A的策略是使两人操作次数最少，问期望操作次数
先统计逆序对cnt,然后每次要么减一个逆序对，要么加一个逆序对，然后再减一个逆序对
E[i]消i个逆序对的期望步数，因为AB两个操作分割后难以递推，那么直接一轮一轮绑定来算，
E[i]=0.5*(E[i-2]+2)+0.5*(E[i]+2)
E[0]=0,E[1]=1，求E[cnt]

#include<bits/stdc++.h>
using namespace std;
#define N 3005
int n,p[N];
int C[N];
void update(int x,int v){
    while(x<=n){
        C[x]+=v;
        x+=x&-x;
    }
}
int query(int x){
    int res=;
    while(x){
        res+=C[x];
        x-=x&-x;
    }
    return res;
}
double E[N*N];
int main(){
    cin>>n;
    int cnt=;
    for(int i=;i<=n;i++){
        cin>>p[i];
        cnt+=query(n)-query(p[i]);
        update(p[i],);
    }
    E[]=;E[]=;
    for(int i=;i<=cnt;i++)
        E[i]=+E[i-];
    printf("%lf\n",E[cnt]);
}

cf235b——概率期望的性质，

n个点，第i个点有pi概率是1，对于一段连续的长度为len的1，得分为len*len,问这个序列的得分期望值

核心：把求连续段的期望 转化成求在这个连续段内任意点对(i,j)的贡献期望和+单点的贡献期望和

长度为len的段得分为len*len，考虑到平方，可以将其转化为统计点对
那么 len*len=2*C(len,2)+len
由这个等式右边第一项可以看出，长为len的连续段里每个点对(i,j)的贡献是2，这个点对出现的概率是mul{p[i]...p[j]}
原来要求的是len段的期望：len*len*其出现的概率，现在把这个段的期望拆成很多点对期望的和，(i,j)的期望就是2*mul{p[i]..p[j]}
右边第二项可以看出每个单点的贡献是1， 其出现概率就是pi

最后的结果是任意两个点对的期望和*2+单点期望和

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int const MAX = 1e5 + ;
double dp[MAX], p[MAX];

int main()
{
    int n;
    scanf("%d", &n);
    double ans = ;
    for(int i = ; i <= n; i++)
    {
        scanf("%lf", &p[i]);
        ans += p[i];
    }
    for(int i = ; i <= n; i++)
    {
        dp[i] = (dp[i - ] + p[i - ]) * p[i];
        ans +=  * dp[i];
    }
    printf("%.10f\n", ans);
}

cf768D——标准二维概率dp

一开始想着按求期望那个套路来求，最后发现一个二维概率dp可以直接解决

有k种不同的球，每天随机得到一种颜色的球，问每种球至少得到一个的概率大于p的期望天数
dp[i][j]表示前i天得到j个不同的求的概率
dp[0][0]=1,dp[1][1]=1
dp[i][j]=j/k*dp[i-1][j]+(k-(j-1))/k*dp[i-1][j-1]
目标状态是dp[1..10000][k]
对于每个询问p，枚举i[1,10000],只要dp[i][k]>=p,就是答案

#include<bits/stdc++.h>
using namespace std;
#define N 1005
double p,dp[][N];
int k,q;
int main(){
    cin>>k>>q;
    dp[][]=;
    for(int i=;i<=;i++)
        for(int j=;j<=min(i,k);j++)
            dp[i][j]=1.0*j/k*dp[i-][j]+1.0*(k-(j-))/k*dp[i-][j-];
    while(q--){
        cin>>p;
        p/=;
        for(int i=;i<=;i++)
            if(dp[i][k]>=p){
                cout<<i<<'\n';
                break;
            }
    }
}

cf15E——状态压缩+概率dp

/*
dp[S]表示状态为S的概率
dp[(1<<n)-1]=1,从大到小枚举S（或记忆化搜索），然后再枚举任意一个数位，来更新其他状态就可以
复杂度约为2^26
*/
#include<bits/stdc++.h>
using namespace std;
int n;
double dp[<<],a[][];
int count(int S){
    int res=;
    for(int i=;i<n;i++)
        if(S>>i & )res++;
    return res;
}
int main(){
    cin>>n;
    for(int i=;i<n;i++)
        for(int j=;j<n;j++)
            cin>>a[i][j];

    int mask=(<<n)-;
    dp[mask]=;

    for(int S=mask;S;S--){
        int cnt=count(S);
        if(cnt<=)continue;
        cnt=cnt*(cnt-)/;
        for(int i=;i<n;i++)if(S>>i & ){
            for(int j=i+;j<n;j++)if(S>>j & ){
                if(i==j)continue;
                dp[S-(<<j)]+=a[i][j]*dp[S]/cnt;
                dp[S-(<<i)]+=a[j][i]*dp[S]/cnt;
            }
        }
    }

    for(int i=;i<n;i++)
        printf("%.10lf ",dp[<<i]);

    return ;
}

cf912d——优先队列贪心

1. 在nm网格图上标记k个点，然后用r*r的矩阵随机覆盖网格图，得分是覆盖住的点的个数
2. 现在求一种标记策略，使随机覆盖得分的期望最大
3. 对于一种标记策略，随机覆盖的期望可以转化为每个点被覆盖的期望值之和
4. 显然最中间的点的被覆盖期望最大，然后是其四周，依次类推
5. 用优先队列来维护，每次弹出一个元素，加入其周围四个元素，取前k个

#include<bits/stdc++.h>
#include<queue>
using namespace std;
#define N 100005
#define ll long long
struct Node{
    ll x,y;
    double e;
    Node(){}
    Node(ll x,ll y,double e):x(x),y(y),e(e){}
};
bool operator<(Node a,Node b){
    return a.e<b.e;
}
priority_queue<Node>pq;
map<pair<ll,ll> ,int>vis;
double ans;

ll n,m,r,k;
double calc(ll x,ll y){
    ll up=max(1ll,x-r+),down=min(n-r+,x);
    ll left=max(1ll,y-r+),right=min(m-r+,y);
    return 1.0*(down-up+)*(right-left+)/(n-r+)/(m-r+);
}

int a[]={-,,,},b[]={,,,-};

int main(){
    cin>>n>>m>>r>>k;
    Node s;
    s.x=r;s.y=r;
    s.e=calc(s.x,s.y);
    pq.push(s);

    while(pq.size() && k){
        Node c=pq.top();pq.pop();
        ll x=c.x,y=c.y;
        if(vis[make_pair(x,y)]==)continue;
        vis[make_pair(x,y)]=;
        k--;ans+=c.e;

        for(int i=;i<;i++){
            ll dx=x+a[i],dy=y+b[i];
            if(dx< || dy< || dx>n || dy>m)continue;
            Node t;
            t.x=dx,t.y=dy;
            t.e=calc(dx,dy);
            pq.push(t);
        }
    }

    printf("%.10lf\n",ans);
} 

cf452C——组合数学概率推导

一副牌n张牌，把m副牌混在一起，再抽出n张，有放回地抽取两张，问一样的概率
当只有一副牌时，抽到和原来一样的概率是1/n
当有m副牌时，分成两部分考虑
　　第一部分：第二次抽的是第一次抽的那张牌，概率是1/n
　　第二部分，第二次抽的不是第一次抽的那张牌，但是和第一次抽的相同，概率是(n-1)/n*(n-1)/(n*m-1)
为什么要分阶段考虑：因为两次洗牌时的洗牌范围不同，所以需要对每个范围求一次概率
　　先在n*m张牌里取一张牌，然后放到范围n里洗牌，那么下一次还取到这张牌的概率是1/n，不取到这张牌的概率是(n-1)/n
　　从其他n-1张牌里取出和这张牌相同的概率是(n-1)/(n*m-1)

#include<bits/stdc++.h>
using namespace std;

int main()
{
    double n,m;
    cin>>n>>m;
    if (n==&&m==){printf("1\n");return ;}
    double a=1.0/n;
    double b=(n-)*(m-)/n/(n*m-);
    printf("%.7lf\n",a+b);

} 

cf261b ——组合数学+dp，期望=总量/总方案数

1. 给定一个序列ai表示第i个人的体积，现在这n个人随机排列，依次进入体积为n的房间里，问房间里人数的期望
2. 原问题转化成 总方案数/全排列
3. 假定第一个无法进入的人是x，那么进入餐厅的人体积可以是区间[p-a[x]+1,p]
4. 令dp[i,j,k]表示前i个人，进了j个，体积是k的方案数
5. dp[0][0][0]=1,
6. dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-a[i]]
7. 最后要求的是每个 j*j!*(n-j-1)!*dp[n][j][p-a[x]+1,p]，即j*进入j个人的方案数，然后求和就是总方案数

#include<bits/stdc++.h>
using namespace std;
#define N 55
int n,a[N],p;
double dp[N][N][N],F[N];

int main(){
    F[]=;
    for(int i=;i<=;i++)F[i]=1.0*i*F[i-];

    cin>>n;int sum=;
    for(int i=;i<=n;i++)
        cin>>a[i],sum+=a[i];
    cin>>p;
    if(sum<=p){cout<<n<<endl;return ;}

    double ans=;
    for(int x=;x<=n;x++){
        memset(dp,,sizeof dp);
        dp[][][]=;
        for(int i=;i<=n;i++)
            for(int j=;j<=i;j++)
                for(int k=;k<=p;k++){
                    if(x==i){dp[i][j][k]=dp[i-][j][k];continue;}
                    dp[i][j][k]=dp[i-][j][k];
                    if(j && k>=a[i])dp[i][j][k]+=dp[i-][j-][k-a[i]];
                }
        for(int j=;j<n;j++)
            for(int k=max(,p-a[x]+);k<=p;k++)
                ans+=F[j]*F[n-j-]*j*dp[n][j][k];
    }
    printf("%.10lf\n",ans/F[n]);
}