期望DP入门

期望DP一般步骤：

1.模拟过程，找出线性性质，作为阶段（这本质上也是线性DP）

2.涉及DP状态

原则：

体现线性性质

体现边权

根据对期望有无贡献来设计状态

一般在状态设计时需要倒着设计

3.转移

根据边权转移

分为对期望贡献的区别来分开计算贡献

不同情况的概率贡献不一样，因此期望贡献也不一样，因此需要分开考虑

考虑权值时可以递归地考虑

1.

题意：

 

思路：

设一直选直到1号球被选中的期望选择次数是E

可以列方程：

E=1/n+(1-1/n)*(E+1)

求出E=n

2.

 

 思路：

首先概率是一定的

在选的过程中，如果选到了1-K号的某个没被选过的球，剩下就选K-1个，因此线性性质就体现在 剩下还要选多少球 中

所以这个可以记成一个状态

所以最终设出来的状态只有一维：

设dp[i]为还剩下i个球选的选择次数的期望

然后考虑转移

选择的决策可以分为，选对选择次数有贡献的，和选对选择次数没有贡献的

选没被选过且编号在1-K的，就是对次数有贡献的，否则就是没有贡献的

前者的期望贡献：dp[i]+=k/n*(dp[i-1]+1)，边权为1

后者的期望贡献：dp[i]+=(1-k/n)*(dp[i-1]+1)，边权为1

Code：

#include <bits/stdc++.h>

#define int long long

using namespace std;

const int mxn=1e6+10;
const int mxe=1e3+10;
const int mod=1e9+7;

int N,Q,K;
int E[mxn];

int ksm(int a,int b,int mod){
	int res=1;
	while(b){
		if(b&1) res=(res*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
void solve(){
	cin>>N>>Q;
	E[1]=N;
	for(int i=2;i<=N;i++) E[i]=(E[i-1]+N*ksm(i,mod-2,mod)%mod)%mod;
	while(Q--){
		cin>>K;
		cout<<E[K]%mod<<'\n';
	}
}
signed main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int __=1;//cin>>__;
    while(__--)solve();return 0;
}

3.

题意：

 

 思路：

首先看它的决策是什么时，对期望产生贡献

当它选红色且没有被选过的小球时，对期望有贡献，否则就是没有贡献

设计的状态需要体现期望贡献

红色:m

没有被选过:用k表示还需要选多少球，这也体现了线性性质

因为已经选过的红色小球对期望没有贡献，因此可以把选过的红色小球去掉

因此设dp[k][m]为还剩下m个红色小球，且还需要选k个不同编号的红色小球的选择次数的期望

转移：

对期望有贡献的部分：m/n*(dp[k-1][m-1]+1)

对期望无贡献的部分：(1-m/n)*(dp[k][m]+1)

然后解个方程就出来了

dp[k][m]=dp[k-1][m-1]+n/m

Code：

#include <bits/stdc++.h>

#define int long long

using namespace std;

const int mxn=1e2+10;
const int mxe=1e3+10;
const int mod=1e9+7;

int N,M,Q,K;
int E[mxn][mxn];

int ksm(int a,int b,int mod){
	int res=1;
	while(b){
		if(b&1) res=(res*a)%mod;
		a=(a*a)%mod;
		b>>=1;
	}
	return res;
}
void solve(){
	while(cin>>N>>M>>Q){
		E[1][1]=N;
		for(int i=1;i<=M;i++){
			for(int j=1;j<=i;j++){
				E[i][j]=(E[i-1][j-1]+N*ksm(i,mod-2,mod)%mod)%mod;
			}
		}
		while(Q--){
			cin>>K;
			cout<<E[M][K]%mod<<'\n';
		}
	}
}
signed main(){
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	int __=1;//cin>>__;
    while(__--)solve();return 0;
}

4.

题意：

思路：

分为尝试成功和尝试失败两部分进行转移

Code：

#include <bits/stdc++.h>
 
#define int long long
 
using namespace std;
 
const int mxn=1e7+10;
const int mxe=1e3+10;
const int mod=1e9+7;
 
int N;
int a[mxn],Fac[mxn];
 
int ksm(int a,int b,int mod){
    int res=1ll;
    while(b){
        if(b&1) res=(res*a)%mod;
        a=(a*a)%mod;
        b>>=1;
    }
    return res%mod;
}
void F_init(){
    Fac[0]=1;
    for(int i=1;i<mxn;i++) Fac[i]=(Fac[i-1]*i)%mod;
}
void solve(){
    int sum=0;
    for(int i=1;i<=10;i++){
        cin>>a[i];
        sum+=a[i];
    }
    int ans=Fac[sum];
    for(int i=1;i<=10;i++) ans=ans*ksm(Fac[a[i]],mod-2,mod)%mod;
    cout<<ans<<'\n';
}
signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int __=1;//cin>>__;
    F_init();
    while(__--)solve();return 0;
}

5.

题意：

思路：

因为计算期望时需要计算概率，计算概率需要n和s这两个参数

因此在设计状态时需要用这两个参数

设dp[n][s]为，已经发现了n种bug，s个子系统的天数期望

然后可以分为4种情况来转移，每种情况的概率贡献不一样 

Code：

#include <bits/stdc++.h>
 
#define int long long
 
using namespace std;
 
const int mxn=1e3+10;
const int mxe=1e6+10;
const int mod=1e9+7;
const int Inf=1e18;
 
int N,S;
double dp[mxn][mxn];
 
void solve(){
    cin>>N>>S;
    dp[N][S]=0;
    for(int i=N;i>=0;i--){
        for(int j=S;j>=0;j--){
            if(i==N&&j==S) continue;
            dp[i][j]=(N*S+(N-i)*j*dp[i+1][j]+i*(S-j)*dp[i][j+1]+(N-i)*(S-j)*dp[i+1][j+1])/(N*S-i*j);
        }
    }
    cout<<fixed<<setprecision(4)<<dp[0][0]<<'\n';
}
signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int __=1;//cin>>__;
    while(__--)solve();return 0;
}

6.

思路：

同样的，也是设期望时间，然后列方程（转移）

设逃离迷宫的期望时间为E

 Code：

#include <bits/stdc++.h>
 
using namespace std;
 
const int mxn=1e2+10;
const int mxe=1e3+10;
 
int N,idx=0;
int x[mxn];
 
void solve(){
    cin>>N;
    for(int i=1;i<=N;i++) cin>>x[i];
    int s1=0,s2=0,cnt=0;
    for(int i=1;i<=N;i++){
        if(x[i]<0){
            cnt++;
            s2+=(-x[i]);
        }else{
            s1+=x[i];
        }
    }
    int d1=(s1+s2);
    int d2=(N-cnt);
    int d=__gcd(d1,d2);
    d1/=d,d2/=d;
    if(cnt==N) cout<<"Case "<<++idx<<": inf"<<'\n';
    else cout<<"Case "<<++idx<<": "<<d1<<"/"<<d2<<'\n';
}
int main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int __=1;cin>>__;
    while(__--)solve();return 0;
}

7.

题意：

 

思路：

这个的线性性质很明显

设dp[i]为从位置 i 到位置 N 得到金子的价值的期望

它有min(6,N-i)种决策，只要不超过N就行

Code：

#include <bits/stdc++.h>
 
#define int long long
 
using namespace std;
 
const int mxn=1e2+10;
const int mxe=1e6+10;
const int mod=1e9+7;
const int Inf=1e18;
 
int tot=0;
int N;
int a[mxn];
double dp[mxn];
//从位置i到位置N的期望价值
 
void solve(){
    cin>>N;
    for(int i=0;i<=N;i++) dp[i]=0.0;
    for(int i=1;i<=N;i++) cin>>a[i];
    dp[N]=0.0;
    for(int i=N-1;i>=1;i--){
        for(int k=1;k<=6;k++){
            double p=1.0/min((N-i)*1.0,6.0);
            dp[i]+=(dp[i+k]+1.0*a[i+k])*p;
        }
    }
    cout<<fixed<<setprecision(8)<<"Case "<<++tot<<":"<<" "<<dp[1]+a[1]<<'\n';
}
signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int __=1;cin>>__;
    while(__--)solve();return 0;
}

 

8.

 

思路：

Code：

#include <bits/stdc++.h>
 
#define int long long
 
using namespace std;
 
const int mxn=1e5+10;
const int mxe=1e5+10;
const int mod=1e9+7;
const int Inf=1e18;
 
struct ty{
    int to,next;
}edge[mxe<<2];
 
int N,tot=0;
int u,v;
int head[mxn];
double ans=0;
 
void add(int u,int v){
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void G_init(){
    tot=0;
    for(int i=0;i<=N;i++){
        head[i]=-1;
    }
}
void dfs(int u,int fa,int dep){
    ans+=1.0/(1.0*dep);
    for(int i=head[u];~i;i=edge[i].next){
        if(edge[i].to==fa) continue;
        dfs(edge[i].to,u,dep+1);
    }
}
void solve(){
    cin>>N;
    G_init();
    for(int i=1;i<=N-1;i++){
        cin>>u>>v;
        add(u,v);
        add(v,u);
    }
    dfs(1,1,1);
    cout<<fixed<<setprecision(8)<<ans<<'\n';
}
signed main(){
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
    int __=1;//cin>>__;
    while(__--)solve();return 0;
}