概率DP （由一道绿题引起的若干问题。目前为一些老题，蒟蒻的尝试学习1.0）

概率DP：
利用动态规划去解决 概率 期望 的题目。

概率DP 求概率（采用顺推）

从 初始状态推向结果，同一般的DP类似，只是经历了概率论知识的包装。
老题：
添加链接描述
题意：
袋子里有w只白鼠，b只黑鼠，A和B轮流从袋子里抓，谁先抓到白色谁就赢。A每次随机抓一只，B每次随机 抓完一只后 会有另外一只随机老鼠跑出来。如果两个人都没有抓到白色，那么B赢。A先抓，问A赢得概率。
w b 均在1e3以内。
思考：求A赢得概率，和当前袋子中 白鼠 黑鼠得数量有关系。 所以 这个要作为状态量。一般问什么，就设计什么状态。
状态：
dp[i][j]表示 当前 袋中有 i只白鼠 和j 只黑鼠时，A获胜得概率。
起点：dp[0][i]=0,dp[i][0]=1;
终点：dp[w][b]
转移：
1.先手拿到白鼠 dp[i][j]+=i/（i+j)
2.先手黑鼠，后手白鼠 f[i][j]+=0 这种情况不用处理
3.先手黑鼠，后手黑鼠，跑掉白鼠
f[i][j]+=j/(i+j)*(j-1)(i+j-1)i(i+j-2)dp[i-1][j-2]
4.先手黑鼠，后手黑鼠，跑黑鼠：dp[i][j]+=j/(i+j)(j-1)/(i+j-1)(j-2)/(i+j-2)*dp[i][j-3];

#include <bits/stdc++.h>
using namespace std;
void solve()
{int w, b;cin >> w >> b;vector<vector<double>> dp(w + 1, vector<double>(b + 1,0));// 定义 dp[i][j] 为 公主 在 i  个白 j 个 黑 的情况下// 获胜的概率for (int j = 1; j <= b; j++)dp[0][j] = 0;for (int i = 1; i <= w; i++)dp[i][0] = 1;for (int i = 1; i <= w; i++){for (int j = 1; j <= b; j++){dp[i][j] += 1.0*i / (i + j);if (j >= 3)dp[i][j] += 1.0*j / (i + j) * (j - 1) / (i + j - 1) * (j - 2) / (i + j - 2) * dp[i][j - 3];if (i >= 1 && j >= 2)dp[i][j] += 1.0*j / (i + j) * (j - 1) / (i + j - 1) * i / (i + j - 2) * dp[i - 1][j - 2];}}cout<<fixed<<setprecision(9)<<dp[w][b]<<"\n";
}
int main()
{std::cin.tie(nullptr)->sync_with_stdio(false);int t;t = 1;while (t--){solve();}return 0;
}

添加链接描述
有2^n 支球队比赛，每次和相邻的球队踢，两两淘汰，给定任意两支球队互相踢赢得概率。（2^n 的矩阵，表示两支球队之间踢赢的概率）求最后哪知球队最可能夺冠。

b 站上 一个视频很形象。

感觉这道题，就有难点的就是 这个 枚举 i 轮 j 队的对手 队伍。（队伍的编号从 0 开始）
这里使用的神秘的二进制。（啊啊啊，二进制，我是学不会了）
通过一些神秘的观察，大佬发现
枚举K 为队伍的编号
j>>(i-1) ^1 == k>>(i-1)，
那么k 可以是 j 队I轮的对手。

#include <bits/stdc++.h>
using namespace std;
int read()
{int x = 0, f = 1;char ch = getchar();while (!isdigit(ch)){if (ch == '-')f = -1;ch = getchar();}while (isdigit(ch)){x = (x << 1) + (x << 3) + ch - '0';ch = getchar();}return x * f;
}
void solve()
{int lun;while (cin >> lun && lun != -1){int n = 1<<lun;//这个是 人数 vector<vector<double>> a(n, vector<double>(n));for (int i = 0; i < n; i++)for (int j = 0; j < n; j++)cin >> a[i][j];vector<vector<double>> dp(lun + 1, vector<double>(n));for (int i=0;i<n;i++)dp[0][i]=1;for (int i=1;i<=lun;i++){for (int j=0;j<n;j++){for(int k=0;k<n;k++){if(((j>>(i-1)) ^1)  == (k>>(i-1)))dp[i][j]+=dp[i-1][j]*dp[i-1][k]*a[j][k];}}}double mx=-1;int f=-1;for(int i=0;i<n;i++){if (dp[lun][i]>mx){mx=dp[lun][i],f=i;}}cout<<f+1<<"\n"; }}
int main()
{std::cin.tie(nullptr)->sync_with_stdio(false);int t;t = 1;// cin>>t;while (t--){solve();}return 0;
}

概率DP求期望（采用逆推）

由终止状态推到起始状态
一般直接将问题作为DP 的状态
luogu
题意：
一个有向无环图，没有重边和自环，起点为1，终点为n。所有点都可以到达终点。
当到达一个顶点，随机走一条边。求从起点走到终点所经过的路径总长度期望是多少。

状态: dp[u]代表点u 到终点n 的路径总长的期望
起点dp[n]=0;
答案是dp[1]
转移：
dp[u]+=(dp[v]+w)/out[u];
直接dfs ，记忆化搜索就可以。
每条边走一遍，每个节点走一遍。所以时间复杂度是
O(n+m)

#include <bits/stdc++.h>
using namespace std;
const int N=1e5+5;vector<pair<int,double>>e[N];
void solve()
{int n,m;cin>>n>>m;int u,v,w;vector<int>out(n+1);while(m--){cin>>u>>v>>w;e[u].push_back(make_pair(v,w));out[u]++;}vector<double>dp(n+1);dp[n]=0;auto dfs=[&]( auto &&self  ,int u )->void{if (u==n||dp[u]!=0) return; for (int i=0;i<e[u].size();i++){int v=e[u][i].first;int w=e[u][i].second;self(self,v);dp[u]+=(dp[v]+w)/out[u];}};dfs(dfs,1);cout<<fixed<<setprecision(2)<<dp[1]<<"\n";
}
int main()
{int t;t=1;while(t--){solve();}return 0;
}

上面的做法是深搜去做的
我们也可以宽搜去做。
在图中的拓扑排序相当于宽搜。反向建图，使用拓扑排序。

#include <bits/stdc++.h>
using namespace std;const int N=1e5+5;
vector<pair<int,double>>e[N];int main()
{int n,m;cin>>n>>m;vector<double>dp(n+1);vector<int>in(n+1);vector<int>t(n+1);int u,v,w;while(m--){cin>>v>>u>>w;e[u].push_back({v,w});in[v]++;t[v]++;}queue<int>q;q.push(n);dp[n]=0;while(!q.empty()){int u=q.front();q.pop();for (int i=0;i<e[u].size();i++){int v=e[u][i].first;int w=e[u][i].second;dp[v]+=(dp[u]+w)/t[v];in[v]--;if (in[v]==0)q.push(v);}}cout<<fixed<<setprecision(2)<<dp[1]<<"\n";return 0;
}