概率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;
}