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+10; const ll mod = 998244353; int n; ll a[maxn],dp[maxn],P[maxn]; int main(){ cin>>n; for(int i=1;i<=n;i++)scanf("%lld",&a[i]); P[0]=1; for(int i=1;i<=n;i++)P[i]=P[i-1]*2%mod; dp[1]=a[1]*P[n-1]%mod; for(int i=2;i<=n;i++){ dp[i]=((dp[i-1]-a[i-1]*P[n-i]%mod)%mod+mod)%mod; dp[i]=(dp[i]+a[i]*P[n-i]%mod)%mod; } ll ans=0; for(int i=1;i<=n;i++) ans=(ans+dp[i])%mod; cout<<ans<<' '; }
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<<1]; int n,L,k,a[N]; double p[N]; int main(){ cin>>n>>L>>k; for(int i=1;i<=n;i++)cin>>p[i],p[i]*=0.01; for(int i=1;i<=n;i++)cin>>a[i]; dp[0][0][200+k]=1; for(int i=1;i<=n;i++){ for(int j=0;j<=i;j++) for(int l=0;l<=400;l++){ dp[i][j][l]+=(1-p[i])*dp[i-1][j][l];//没赢 if(a[i]==-1){//是奖品 if(l)dp[i][j+1][l-1]+=p[i]*dp[i-1][j][l]; } else {//是背包 dp[i][j+1][min(l+a[i],400)]+=p[i]*dp[i-1][j][l]; } } } double ans=0; for(int j=L;j<=n;j++) for(int l=200;l<=400;l++) ans+=dp[n][j][l]; printf("%.10lf ",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[10],R[10]; double ans[N]; int count(int x){ int res=0; for(int i=0;i<n;i++) if(x>>i & 1)res++; return res; } int main(){ cin>>n; for(int i=0;i<n;i++)cin>>L[i]>>R[i]; for(int i=1;i<=10000;i++){ for(int S=0;S<(1<<n);S++)if(count(S)>=2){ double pp1=0; for(int j=0;j<n;j++)if(S>>j & 1){//情况1，枚举第j个作为>i的选项 double p1=1; if(L[j]>i)p1=1; else if(R[j]<=i)p1=0; else if(R[j]>i && L[j]<=i)p1*=1.0*(R[j]-i)/(R[j]-L[j]+1); for(int k=0;k<n;k++)if(k!=j){ if(S>>k & 1){ if(R[k]<i || L[k]>i)p1=0; else p1*=1.0/(R[k]-L[k]+1); } else { if(L[k]>=i)p1=0; else if(R[k]<i)p1*=1; else if(L[k]<i && R[k]>=i)p1*=1.0*(i-L[k])/(R[k]-L[k]+1); } } pp1+=p1; } double p2=1;//情况2，都选i for(int j=0;j<n;j++){ if(S>>j & 1){//第j人等于i if(L[j]>i || R[j]<i)p2=0; p2*=1.0/(R[j]-L[j]+1); } else {//第j人小于i if(R[j]<i)p2*=1; else if(L[j]>=i)p2=0; else if(L[j]<i && R[j]>=i)p2*=1.0*(i-L[j])/(R[j]-L[j]+1); } } ans[i]+=pp1+p2; } } double sum=0; for(int i=1;i<=10000;i++) sum+=ans[i]*i; printf("%.10lf ",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=1;i<=n;i++)cin>>a[i]; for(int i=1;i<=n;i++){ L[i]=pos[a[i]]; pos[a[i]]=i; } for(int i=1;i<=n;i++) if(L[i]==i) ans+=2*(n-i+1)-1; else ans+=2ll*(i-L[i])*(n-i+1)-1; ans/=1ll*n*n; printf("%.10lf ",ans); }
cf109b——求概率转化为 统计所有合法情况个数/所有情况个数
- 先把所有lucky数打表，排序后存在数组里
- 一段区间内恰好有k个数，那么这k个数必定是连续的，我们枚举枚举这一段连续的的左右下标i,j可以得到两个取值区间
- 左边界 [v[i-1]+1,v[i]] 右边界[v[j],v[j+1]-1]，然后这两个边界再和[pl,pr],[vl,vr]求交，求有多少可能的取值
- 求出对于每个i,j的合法边界个数，然后统计求和就可以
#include<bits/stdc++.h> using namespace std; #define ll long long ll a[2005],cnt,pl,pr,vl,vr,k; void dfs(ll num){ if(num>=1e9)return; if(num)a[++cnt]=num; dfs(num*10+4);dfs(num*10+7); } ll jiao(ll L1,ll R1,ll L2,ll R2){//求区间交的长度 if(R1<L2 || R2<L1)return 0;//不相交 ll L=max(L1,L2),R=min(R1,R2); return R-L+1; } int main(){ dfs(0); cin>>pl>>pr>>vl>>vr>>k; sort(a+1,a+1+cnt); a[cnt+1]=1e9; ll ans=0; for(int i=1;i+k-1<=cnt;i++){ int j=i+k-1; ll tmp1=jiao(pl,pr,a[i-1]+1,a[i]); ll tmp2=jiao(vl,vr,a[j],a[j+1]-1); ll tmp3=jiao(vl,vr,a[i-1]+1,a[i]); ll tmp4=jiao(pl,pr,a[j],a[j+1]-1); if(k==1){//特判处理 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 ",1.0*ans/((pr-pl+1)*(vr-vl+1))); }
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<<" "; */ if(R1<L2 || R2<L1) return 0; ll L=max(L1,L2),R=min(R1,R2); return R-L+1; } double calc(ll low,ll up){ ll sum=0; for(ll p=1;p<=1e18;p*=10){ sum+=jiao(p,p*2-1,low,up); if(p==1e18)break; } return 1.0*sum/(up-low+1); } int main(){ cin>>n; for(int i=1;i<=n;i++){ cin>>L[i]>>R[i]; p[i]=calc(L[i],R[i]); } cin>>K; k=(n*K)/100; if(n*K%100!=0) k++; dp[0][0]=1; for(int i=1;i<=n;i++) for(int j=0;j<=n;j++){ dp[i][j]+=(1-p[i])*dp[i-1][j]; if(j) dp[i][j]+=p[i]*dp[i-1][j-1]; } double ans=0; for(int i=k;i<=n;i++) ans+=dp[n][i]; printf("%.10lf ",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]=1; for(int i=r;i>=0;i--) for(int j=s;j>=0;j--) for(int k=p;k>=0;k--){ if(i==r && j==s && k==p)continue; int base=(i+j+k+1)*(i+j+k+1); if(i+1<=r && (j!=0||k!=0))dp[i][j][k]+=2.0*(i+1)*k/(base-(i+1)*(i+1)-j*j-k*k)*dp[i+1][j][k]; if(j+1<=s && (i!=0||k!=0))dp[i][j][k]+=2.0*(j+1)*i/(base-i*i-(j+1)*(j+1)-k*k)*dp[i][j+1][k]; if(k+1<=p && (i!=0||j!=0))dp[i][j][k]+=2.0*(k+1)*j/(base-i*i-j*j-(k+1)*(k+1))*dp[i][j][k+1]; } double ans1=0,ans2=0,ans3=0; for(int i=1;i<=r;i++)ans1+=dp[i][0][0]; for(int j=1;j<=s;j++)ans2+=dp[0][j][0]; for(int k=1;k<=p;k++)ans3+=dp[0][0][k]; printf("%.10lf %.10lf %.10lf ",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=0; while(x){ res+=C[x]; x-=x&-x; } return res; } double E[N*N]; int main(){ cin>>n; int cnt=0; for(int i=1;i<=n;i++){ cin>>p[i]; cnt+=query(n)-query(p[i]); update(p[i],1); } E[0]=0;E[1]=1; for(int i=2;i<=cnt;i++) E[i]=4+E[i-2]; printf("%lf ",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 + 5; double dp[MAX], p[MAX]; int main() { int n; scanf("%d", &n); double ans = 0; for(int i = 1; i <= n; i++) { scanf("%lf", &p[i]); ans += p[i]; } for(int i = 2; i <= n; i++) { dp[i] = (dp[i - 1] + p[i - 1]) * p[i]; ans += 2 * dp[i]; } printf("%.10f ", 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[10005][N]; int k,q; int main(){ cin>>k>>q; dp[0][0]=1; for(int i=1;i<=10000;i++) for(int j=1;j<=min(i,k);j++) dp[i][j]=1.0*j/k*dp[i-1][j]+1.0*(k-(j-1))/k*dp[i-1][j-1]; while(q--){ cin>>p; p/=2000; for(int i=1;i<=10000;i++) if(dp[i][k]>=p){ cout<<i<<' '; 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[1<<18],a[20][20]; int count(int S){ int res=0; for(int i=0;i<n;i++) if(S>>i & 1)res++; return res; } int main(){ cin>>n; for(int i=0;i<n;i++) for(int j=0;j<n;j++) cin>>a[i][j]; int mask=(1<<n)-1; dp[mask]=1; for(int S=mask;S;S--){ int cnt=count(S); if(cnt<=1)continue; cnt=cnt*(cnt-1)/2; for(int i=0;i<n;i++)if(S>>i & 1){ for(int j=i+1;j<n;j++)if(S>>j & 1){ if(i==j)continue; dp[S-(1<<j)]+=a[i][j]*dp[S]/cnt; dp[S-(1<<i)]+=a[j][i]*dp[S]/cnt; } } } for(int i=0;i<n;i++) printf("%.10lf ",dp[1<<i]); return 0; }
cf912d——优先队列贪心
- 在nm网格图上标记k个点，然后用r*r的矩阵随机覆盖网格图，得分是覆盖住的点的个数
- 现在求一种标记策略，使随机覆盖得分的期望最大
- 对于一种标记策略，随机覆盖的期望可以转化为每个点被覆盖的期望值之和
- 显然最中间的点的被覆盖期望最大，然后是其四周，依次类推
- 用优先队列来维护，每次弹出一个元素，加入其周围四个元素，取前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+1),down=min(n-r+1,x); ll left=max(1ll,y-r+1),right=min(m-r+1,y); return 1.0*(down-up+1)*(right-left+1)/(n-r+1)/(m-r+1); } int a[4]={-1,1,0,0},b[4]={0,0,1,-1}; 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)]==1)continue; vis[make_pair(x,y)]=1; k--;ans+=c.e; for(int i=0;i<4;i++){ ll dx=x+a[i],dy=y+b[i]; if(dx<1 || dy<1 || dx>n || dy>m)continue; Node t; t.x=dx,t.y=dy; t.e=calc(dx,dy); pq.push(t); } } printf("%.10lf ",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==1&&m==1){printf("1 ");return 0;} double a=1.0/n; double b=(n-1)*(m-1)/n/(n*m-1); printf("%.7lf ",a+b); }
cf261b ——组合数学+dp，期望=总量/总方案数
- 给定一个序列ai表示第i个人的体积，现在这n个人随机排列，依次进入体积为n的房间里，问房间里人数的期望
- 原问题转化成 总方案数/全排列
- 假定第一个无法进入的人是x，那么进入餐厅的人体积可以是区间[p-a[x]+1,p]
- 令dp[i,j,k]表示前i个人，进了j个，体积是k的方案数
- dp[0][0][0]=1,
- dp[i][j][k]=dp[i-1][j][k]+dp[i-1][j-1][k-a[i]]
- 最后要求的是每个 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[0]=1; for(int i=1;i<=50;i++)F[i]=1.0*i*F[i-1]; cin>>n;int sum=0; for(int i=1;i<=n;i++) cin>>a[i],sum+=a[i]; cin>>p; if(sum<=p){cout<<n<<endl;return 0;} double ans=0; for(int x=1;x<=n;x++){ memset(dp,0,sizeof dp); dp[0][0][0]=1; for(int i=1;i<=n;i++) for(int j=0;j<=i;j++) for(int k=0;k<=p;k++){ if(x==i){dp[i][j][k]=dp[i-1][j][k];continue;} dp[i][j][k]=dp[i-1][j][k]; if(j && k>=a[i])dp[i][j][k]+=dp[i-1][j-1][k-a[i]]; } for(int j=1;j<n;j++) for(int k=max(0,p-a[x]+1);k<=p;k++) ans+=F[j]*F[n-j-1]*j*dp[n][j][k]; } printf("%.10lf ",ans/F[n]); }