'commit'

TangDou/AcWing_TiGao/T5/QiWang/217.drawio

@@ -0,0 +1 @@
+<mxfile host="Electron" modified="2022-06-20T07:53:04.288Z" agent="5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) draw.io/16.0.2 Chrome/96.0.4664.55 Electron/16.0.5 Safari/537.36" etag="jNveJB-z9TWn2FKd464S" version="16.0.2" type="device"><diagram id="S7yhPZ9SSO8EGXcPaCVl" name="第 1 页">5VpLc9owEP41zLSHMtbLj2NDHj00M+mkbdLePFiAEmNRI4rJr6+MZbAlB0gCVgkzHLwraWV9+3m1WtFBvXF2lYaT0TWPaNyBTpR10HkHQoAh7OQ/J1oUGt8jhWKYskh1Witu2RNVSkdpZyyi01pHwXks2KSu7PMkoX1R04Vpyuf1bgMe12edhENqKG77YWxq71gkRkrrErxu+ELZcFRODdygaBmHZW+1lOkojPi8okIXHdRLORfF0zjr0ThHrwSmGHf5TOvqzVKaiF0GDB7cy3F2+fPp4QpP/izI7Ovi/pOy8jeMZ2rFD+ptxaLEQJqRcEvhbD5igt5Own7eMpcel7qRGMdSAvIxnE4KHwxYRuWsZ1OR8scVcFhqBjwRyssQlbKaqmFF5evRVNCsolIrvKJ8TEW6kF1Ua4AV2opvIFDyfO09olSjit9KXaj4MlxZXiMqHxSozQBf9JxfT78ZFL9/XH0PxfUw/PatAeAM2EbYgLMB9GcRdoM6wtCxjDA0EUZHjbDneTWEEbKMMDIRhkeNcKBxGNvmMDYRfjxqhH2/jjCxzWFiIJwcNcAu1AC2TWHXANjEN4k+5zmZlPpxOJ2yfh3WlM+SKMfz3NEQ9KRMMybuVVv+/Ct/7hIlnWeVpvNFKSRyaffK/FKojMrF9bClVI4z/VkshkZGumgkK1M+S/t0e84lwnRIxbbUwSTAjg5OaRwK9rf+uk1eVzPccCYXst6EHC1EehpximWqUdW0UzdENENQM1TgYBhaknC17Nfz0jN4edeQgckPUdTJWFCgx2OeSk3CkzwuDFgca6owZsMkZ7TkAZX6s/yzZvIE8Vk1jFkUxc8Flc2U30cg1uIE8M044TbQCB0qTvitxYku9CuhArwmULw4TORGb2jKJFY5GZa9LIQOaDN0BNoXLw3vJ3RApBk6cOgI2qMq2Zmp/8XWhK3yy8V1Wug5za788n3YdT3PdQMijWpWEfa6aHn4klsfQq7jtsq9sgB2ePKBN1BvFTYrKdUugdMCZZFVypZlz7dSNgBBTlnfgW7g5QyumSXY6WIMCCI+CggO2mWsWeo6VLh8wQlgA2e1MwHcwtmltJ+9fVOVZSuRiVUiBxtCpsztq40owK8jOXBg/XPBoN0zAzBrinum8u603HZU3SMD8TEwEDj6yVTPCnelmavXqFo+mQKzrnqogPmC/PK1W/q+8tJNtyj/NzNPIy81S9Ut7PJvyEs9WI+nEi+7+zw8Bi6/oyhrVv7vGi4IT6YACD3LBUBg3hTcNdwnvluHGJ8Wari6adcjTTVy8/7x3XrE9zSHNPxppF2HmEXywYcMfDwdl7hAcwm27RKzGCxdgk7IJZ7216rVRZ4tl5Tz110CT8gl+t6Obe/t0KwBSpc8npBL9DsrQg7mEimu/z1apMvrP+Gii38=</diagram></mxfile>

TangDou/AcWing_TiGao/T5/QiWang/217.md

@@ -0,0 +1,204 @@
+##[$AcWing$ $217$. 绿豆蛙的归宿](https://www.acwing.com/problem/content/description/219/)
+
+### 一、题目描述
+给出一个有向无环的连通图，起点为 $1$ ，终点为 $N$，每条边都有一个长度。
+
+数据保证从起点出发能够到达图中所有的点，图中所有的点也都能够到达终点。
+
+绿豆蛙从起点出发，走向终点。
+
+到达每一个顶点时，如果有 $K$ 条离开该点的道路，绿豆蛙可以选择任意一条道路离开该点，并且走向每条路的概率为 $1/K$。
+
+现在绿豆蛙想知道，从起点走到终点所经过的路径总长度的 **期望** 是多少？
+
+**输入格式**
+第一行: 两个整数 $N，M$，代表图中有 $N$ 个点、$M$ 条边。
+
+第二行到第 $1+M$ 行: 每行 $3$ 个整数 $a,b,c$，代表从 $a$ 到 $b$ 有一条长度为 $c$ 的有向边。
+
+**输出格式**
+输出从起点到终点路径总长度的 **期望值**，结果四舍五入保留两位小数。
+
+**数据范围**
+$1≤N≤10^5,1≤M≤2N$
+
+**输入样例：**
+```cpp {.line-numbers}
+4 4
+1 2 1
+1 3 2
+2 3 3
+3 4 4
+```
+
+**输出样例：**
+```cpp {.line-numbers}
+7.00
+```
+
+### 二、数学期望
+
+首先明白一点：到达某个结果的期望值 = 这个结果 * 从起始状态到这个状态的概率
+
+**什么意思呢？**
+
+如图：
+<center><img src='https://img-blog.csdnimg.cn/c8715153345a4f48b17bca9db4a18c45.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxOTY4MTU1,size_16,color_FFFFFF,t_70'></center>
+
+我们计算从$1$号点到$3$号点的期望距离
+
+路径$1$.  $\displaystyle 1 \rightarrow 3:E_1=2×\frac{1}{2}=1$
+
+路径$2$.  $\displaystyle 1 \rightarrow 2 \rightarrow 3:E_2=1×\frac{1}{2}+3×\frac{1}{2}×1=2$
+
+这里路径$2$中从$1$到$2$概率为$\displaystyle \frac{1}{2}$,但单看从$2$到$3$概率就是$1$，但是从$1$到$3$那就是从($1$到$2$的概率)$\displaystyle \frac{1}{2}$×$1$($2$到$3$的概率)=$\displaystyle \frac{1}{2}$。 
+
+所以从 点$1$ 到 点$3$ 的数学期望值=$1+2=3$
+><font color='red'><h5>总结
+① 概率是叠乘的
+② 概率计算出来后，需要乘上边权值，做为本边权的贡献值
+③ 所有贡献值累加和就是期望
+</h5></font> 
+
+
+本题有 **正推** 和 **倒推** 两种写法:
+
+#### 正推法
+<center><img src='https://img-blog.csdnimg.cn/ba5182288859446386d641317c691cda.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxOTY4MTU1,size_16,color_FFFFFF,t_70'></center>
+
+设：
+- $a_1, a_2, a_3 … a_k$ 到 $j$ 的权值为 $w_1, w_2, w_3 … w_k$,
+- 从起点到这$k$个点的概率为：$p_1, p_2, p_3 … p_k$
+- 每个点的出度为：$out_1, out_2, out_3, … , out_k$
+
+这里的$1\sim k$个点的从起点的到该点的概率一定是确定的,也就是说这个点的概率是被更新完的，即此时这个点的入度为$0$！
+
+那么就有：
+$$f(i):表示从起点到i点的期望距离$$
+$$f(j)=\frac{f(1)+w_1\times p_1}{out_1}+\frac{f(2)+w_2\times p_2}{out_2}+\frac{f(3)+w_3\times p_3}{out_3}+...+\frac{f(k)+w_k\times p_k}{out_k} $$
+
+#### 正推代码
+```cpp {.line-numbers}
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 1e5 + 10, M = N << 1;
+
+// 邻接表
+int h[N], e[M], ne[M], w[M], idx;
+void add(int a, int b, int c) {
+    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
+}
+
+int n, m; // n个顶点，m条边
+
+int out[N], in[N]; // 出度,入度
+double f[N], g[N]; // f:数学期望结果 g:概率
+
+void topsort() {
+    queue<int> q;
+    // 起点为1,起点的概率为100%
+    q.push(1);
+    g[1] = 1.0;
+    f[1] = 0.0;
+
+    // DAG，执行拓扑序,以保证计算的顺序正确，确保递归过程中，前序数据都已处理完毕
+    while (q.size()) {
+        auto u = q.front();
+        q.pop();
+
+        for (int i = h[u]; ~i; i = ne[i]) { // 枚举的是每边相邻边
+            int v = e[i];                   // 此边，一端是t，另一端是j
+            // 此边边条w[i]
+            f[v] += (f[u] + w[i] * g[u]) / out[u];
+            g[v] += g[u] / out[u]; // g[j]也需要概率累加
+            // 拓扑序的标准套路
+            in[v]--;
+            if (!in[v]) q.push(v);
+        }
+    }
+}
+
+int main() {
+    // 初始化邻接表
+    memset(h, -1, sizeof h);
+    cin >> n >> m;
+
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        add(a, b, c);
+        // 维护出度，入度
+        out[a]++, in[b]++;
+    }
+    // 拓扑序
+    topsort();
+
+    // 正向递推，输出结果，保留两位小数
+    printf("%.2lf", f[n]);
+
+    return 0;
+}
+```
+#### 倒推法
+现在学会了正推，来看看 **逆推**，即 **从终点找到起点**
+
+
+<center><img src='https://cdn.acwing.com/media/article/image/2022/06/20/64630_41a7f81ff0-217.drawio.png'></center>
+
+设 $f[x]$ 表示结点 $x$ 走到终点所经过的路径的期望长度。显然 $f[n]=0$ ，最后要求 $f[1]$ 。
+
+一般来说，**初始状态确定时可用顺推，终止状态确定时可用逆推**。
+
+设 $x$ 出发有 $k$ 条边，分别到达 $y_1,y_2...y_k$ ，边长分别为 $z_1,z_2...z_k$ ，根据数学期望的定义和性质，有：
+
+$$f[x]=\frac 1 k\times (f[y_1]+z_1)+\frac 1 k\times (f[y_2]+z_2)+...+\frac 1 k\times (f[y_k]+z_k)=\frac 1 k \times \sum_{i=1}^k(f[y_i]+z_i)$$
+根据设定已经确定是能够到达 $n$ 点了，概率为 $1$ 。
+
+$f[n]$ 已知，需要求解 $f[1]$ ，建立 **反向图**，按照 **拓扑序** 求解。
+
+#### 倒推代码
+```cpp {.line-numbers}
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 100010, M = N << 1;
+int n, m;
+int in[N], g[N]; // 入度，入度的备份数组，原因：in在topsort中会不断变小受破坏
+double f[N];
+
+// 链式前向星
+int e[M], h[N], idx, w[M], ne[M];
+void add(int a, int b, int c = 0) {
+    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
+}
+
+void topsort() {
+    queue<int> q;
+    q.push(n);
+    f[n] = 0; // n到n的距离期望是0
+    while (q.size()) {
+        int u = q.front();
+        q.pop();
+        for (int i = h[u]; ~i; i = ne[i]) { // 枚举每条入边(因为是反向图)
+            int v = e[i];
+            f[v] += (f[u] + w[i]) / g[v];
+            in[v]--;
+            if (in[v] == 0) q.push(v);
+        }
+    }
+}
+int main() {
+    memset(h, -1, sizeof h);
+    cin >> n >> m;
+
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        add(b, a, c); // 反向图,计算从n到1
+        in[a]++;      // 入度
+        g[a] = in[a]; // 入度数量
+    }
+    topsort();
+    printf("%.2lf\n", f[1]);
+    return 0;
+}
+```

TangDou/AcWing_TiGao/T5/QiWang/217_DaoTui.cpp

@@ -0,0 +1,43 @@
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 100010, M = N << 1;
+int n, m;
+int in[N], g[N]; // 入度，入度的备份数组，原因：in在topsort中会不断变小受破坏
+double f[N];
+
+// 链式前向星
+int e[M], h[N], idx, w[M], ne[M];
+void add(int a, int b, int c = 0) {
+    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
+}
+
+void topsort() {
+    queue<int> q;
+    q.push(n);
+    f[n] = 0; // n到n的距离期望是0
+    while (q.size()) {
+        int u = q.front();
+        q.pop();
+        for (int i = h[u]; ~i; i = ne[i]) { // 枚举每条入边(因为是反向图)
+            int v = e[i];
+            f[v] += (f[u] + w[i]) / g[v];
+            in[v]--;
+            if (in[v] == 0) q.push(v);
+        }
+    }
+}
+int main() {
+    memset(h, -1, sizeof h);
+    cin >> n >> m;
+
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        add(b, a, c); // 反向图,计算从n到1
+        in[a]++;      // 入度
+        g[a] = in[a]; // 入度数量
+    }
+    topsort();
+    printf("%.2lf\n", f[1]);
+    return 0;
+}

TangDou/AcWing_TiGao/T5/QiWang/217_ZhengTui.cpp

@@ -0,0 +1,59 @@
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 1e5 + 10, M = N << 1;
+
+// 邻接表
+int h[N], e[M], ne[M], w[M], idx;
+void add(int a, int b, int c) {
+    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
+}
+
+int n, m; // n个顶点，m条边
+
+int out[N], in[N]; // 出度,入度
+double f[N], g[N]; // f:数学期望结果 g:概率
+
+void topsort() {
+    queue<int> q;
+    // 起点为1,起点的概率为100%
+    q.push(1);
+    g[1] = 1.0;
+    f[1] = 0.0;
+
+    // DAG，执行拓扑序,以保证计算的顺序正确，确保递归过程中，前序数据都已处理完毕
+    while (q.size()) {
+        auto u = q.front();
+        q.pop();
+
+        for (int i = h[u]; ~i; i = ne[i]) { // 枚举的是每边相邻边
+            int v = e[i];                   // 此边，一端是t，另一端是j
+            // 此边边条w[i]
+            f[v] += (f[u] + w[i] * g[u]) / out[u];
+            g[v] += g[u] / out[u]; // g[j]也需要概率累加
+            // 拓扑序的标准套路
+            in[v]--;
+            if (!in[v]) q.push(v);
+        }
+    }
+}
+
+int main() {
+    // 初始化邻接表
+    memset(h, -1, sizeof h);
+    cin >> n >> m;
+
+    while (m--) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        add(a, b, c);
+        // 维护出度，入度
+        out[a]++, in[b]++;
+    }
+    // 拓扑序
+    topsort();
+
+    // 正向递推，输出结果，保留两位小数
+    printf("%.2lf", f[n]);
+
+    return 0;
+}

TangDou/AcWing_TiGao/T5/QiWang/218.md

@@ -0,0 +1,152 @@
+##[$AcWing$ $218$. 扑克牌 ](https://www.acwing.com/problem/content/description/220/)
+
+### 一、题目描述
+$Admin$ 生日那天，$Rainbow$ 来找 $Admin$ 玩扑克牌。
+
+玩着玩着 $Rainbow$ 觉得太没意思了，于是决定给 $Admin$ 一个考验。
+
+$Rainbow$ 把一副扑克牌($54$张)随机洗开，倒扣着放成一摞。
+
+然后 $Admin$ 从上往下依次翻开每张牌，每翻开一张黑桃、红桃、梅花或者方块，就把它放到对应花色的堆里去。
+
+$Rainbow$ 想问问 $Admin$，得到 $A$ 张黑桃、$B$ 张红桃、$C$ 张梅花、$D$ 张方块需要翻开的牌的张数的期望值 $E$ 是多少？
+
+特殊地，如果翻开的牌是大王或者小王，$Admin$ 将会把它作为某种花色的牌放入对应堆中，使得放入之后 $E$的值尽可能小。
+
+由于 $Admin$ 和 $Rainbow$ 还在玩扑克，所以这个程序就交给你来写了。
+
+**输入格式**
+输入仅由一行，包含四个用空格隔开的整数，$A,B,C,D$。
+
+**输出格式**
+输出需要翻开的牌数的期望值 $E$，四舍五入保留 $3$ 位小数。
+
+如果不可能达到输入的状态，输出 `-1.000`。
+
+**数据范围**
+$0≤A,B,C,D≤15$
+
+**输入样例：**
+```cpp {.line-numbers}
+1 2 3 4
+```
+
+**输出样例：**
+```cpp {.line-numbers}
+16.393
+```
+
+### 二、题意分析
+
+<font color='red' size=4><b>$Q$:为什么从终止状态向起始状态递推？</b></font>
+
+**答**：满足条件的终止状态较多，而起始状态唯一。考虑以终止状态为初值，起始状态为目标，进行动态规划。
+
+#### 状态表示
+$f[a][b][c][d][x][y]$ : 当前已翻开状态下，还需翻开牌的数量 **期望数**。
+
+- $a,b,c,d$ 为已翻开的各类牌 (黑红花片) 的数量
+- $x,y$代表大、小王的状态（$0$为未翻开，$1$代表已翻开且当做黑桃，以此类推）, 设 $rst$ 为剩余牌的数量。
+$$rst=54-a-b-c-d-(x!=0)-(y!=0)$$
+
+若 $a < 13$，则当前抽到黑桃的贡献为
+
+$$\frac{13−a}{rst} \times f[a+1][b][c][d][x][y]$$
+
+其余花色同理。若小王被抽取，取可转移状态期望最小的一个进行状态转移，其贡献为:
+
+$$\frac{1}{rst} \times \min_{1≤i≤4}f[a][b][c][d][i][y]$$
+
+大王同理。
+
+​记忆化搜索求解，若无牌可抽仍未到达 $a > = A \&\& b > = B \&\& c > = C \&\& d > = D$ 的终止状态，则期望为正无穷，代表不合法的状态。
+
+
+#### 三、实现代码
+
+```cpp {.line-numbers}
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 15;
+const int INF = 0x3f3f3f3f;
+double f[N][N][N][N][5][5];
+int st[N][N][N][N][5][5];
+int A, B, C, D;
+
+//如果大小王翻出来放1里，则a++,放2里b++,...
+void add(int &a, int &b, int &c, int &d, int x) {
+    if (x == 1) a++;
+    if (x == 2) b++;
+    if (x == 3) c++;
+    if (x == 4) d++;
+}
+
+/*
+功能：计算当前状态f(a,b,c,d,x,y)下的期望值
+*/
+double dfs(int a, int b, int c, int d, int x, int y) {
+    //记忆化,同时因为f为double类型，不能使用传统的memset(0x3f)之类
+    //进行初始化并判断是否修改过，只能再开一个st数组
+    if (st[a][b][c][d][x][y]) return f[a][b][c][d][x][y];
+    st[a][b][c][d][x][y] = 1;
+
+    //递归出口：当前状态是否到达目标状态，目标状态的期望值是0
+    int ta = a, tb = b, tc = c, td = d;             //抄出来
+    add(ta, tb, tc, td, x), add(ta, tb, tc, td, y); //大王小王会改变四个花色的数量
+    if (ta >= A && tb >= B && tc >= C && td >= D) return 0;
+
+    //当前状态下的剩余牌数量
+    int rst = 54 - ta - tb - tc - td;
+    if (rst == 0) return INF; //还没有完成目标，没有剩余的牌了，无解
+
+    //当前状态可以向哪些状态转移
+    // Q:v为什么要初始化为1?
+    // A:看题解内容
+    double v = 1;
+    if (a < 13) //黑桃有剩余，可能选出的是黑桃
+        v += dfs(a + 1, b, c, d, x, y) * (13 - a) / rst;
+    if (b < 13) //红桃有剩余，可能选出的是红桃
+        v += dfs(a, b + 1, c, d, x, y) * (13 - b) / rst;
+    if (c < 13) //梅花有剩余，可能选出的是梅花
+        v += dfs(a, b, c + 1, d, x, y) * (13 - c) / rst;
+    if (d < 13) //方块有剩余，可能选出的是方块
+        v += dfs(a, b, c, d + 1, x, y) * (13 - d) / rst;
+
+    //如果小王没有被选出
+    if (x == 0)
+        v += min(min(dfs(a, b, c, d, 1, y), dfs(a, b, c, d, 2, y)), min(dfs(a, b, c, d, 3, y), dfs(a, b, c, d, 4, y))) / rst;
+
+    //如果大王没有被选出
+    if (y == 0)
+        v += min(min(dfs(a, b, c, d, x, 1), dfs(a, b, c, d, x, 2)), min(dfs(a, b, c, d, x, 3), dfs(a, b, c, d, x, 4))) / rst;
+
+    return f[a][b][c][d][x][y] = v;
+}
+
+int main() {
+    cin >> A >> B >> C >> D;
+    //① 终点状态不唯一，起点是唯的的，所以以起点为终点，以终点为起点,反着推
+    //② AcWing 217. 绿豆蛙的归宿　需要建图，本题不用建图
+    double res = dfs(0, 0, 0, 0, 0, 0); //四种花色、大小王都还没有被抽取
+
+    if (res > INF / 2) //因为是浮点数，不能用等号判断是不是相等，简单的办法就是INF/2
+        puts("-1.000");
+    else
+        printf("%.3f\n", res);
+    return 0;
+}
+```
+
+###  四、期望值为什么初始化为$1$?
+
+$f[i]$: 从$i$卡牌状态到终点状态所需要的**期望卡牌数**
+
+每次抽一张牌变到下个状态，所以每条路径的权值为$1$
+
+$$\large f[v]=p_1×(f[1]+1)+p_2×(f[2]+1)+p_3×(f[3]+1)+…+p_k×(f[k]+1) = \\ 
+\sum_{i=1}^{k}p_i+\sum_{i=1}^{k}p_i \times f[i]
+$$
+
+ 因为$v$一定能到达下个局面，所以下个状态的概率和为$1$，这里的$\large \displaystyle \sum_{i=1}^{k}p_i=1$ 那么就有：$\displaystyle \large f[v]=1+\sum_{i=1}^{k}p_i \times f[i]$ 
+综上这里的$f[v]$可以初始化为$1$！
+<center><img src='https://img-blog.csdnimg.cn/4479c699431c421da4ab5d4f3f3db1bc.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzUxOTY4MTU1,size_16,color_FFFFFF,t_70'></center>

TangDou/AcWing_TiGao/T5/QiWang/218_dfs.cpp

@@ -0,0 +1,70 @@
+#include <bits/stdc++.h>
+using namespace std;
+const int N = 15;
+const int INF = 0x3f3f3f3f;
+double f[N][N][N][N][5][5];
+int st[N][N][N][N][5][5];
+int A, B, C, D;
+
+//如果大小王翻出来放1里，则a++,放2里b++,...
+void add(int &a, int &b, int &c, int &d, int x) {
+    if (x == 1) a++;
+    if (x == 2) b++;
+    if (x == 3) c++;
+    if (x == 4) d++;
+}
+
+/*
+功能：计算当前状态f(a,b,c,d,x,y)下的期望值
+*/
+double dfs(int a, int b, int c, int d, int x, int y) {
+    //记忆化,同时因为f为double类型，不能使用传统的memset(0x3f)之类
+    //进行初始化并判断是否修改过，只能再开一个st数组
+    if (st[a][b][c][d][x][y]) return f[a][b][c][d][x][y];
+    st[a][b][c][d][x][y] = 1;
+
+    //递归出口：当前状态是否到达目标状态，目标状态的期望值是0
+    int ta = a, tb = b, tc = c, td = d;             //抄出来
+    add(ta, tb, tc, td, x), add(ta, tb, tc, td, y); //大王小王会改变四个花色的数量
+    if (ta >= A && tb >= B && tc >= C && td >= D) return 0;
+
+    //当前状态下的剩余牌数量
+    int rst = 54 - ta - tb - tc - td;
+    if (rst == 0) return INF; //还没有完成目标，没有剩余的牌了，无解
+
+    //当前状态可以向哪些状态转移
+    // Q:v为什么要初始化为1?
+    // A:看题解内容
+    double v = 1;
+    if (a < 13) //黑桃有剩余，可能选出的是黑桃
+        v += dfs(a + 1, b, c, d, x, y) * (13 - a) / rst;
+    if (b < 13) //红桃有剩余，可能选出的是红桃
+        v += dfs(a, b + 1, c, d, x, y) * (13 - b) / rst;
+    if (c < 13) //梅花有剩余，可能选出的是梅花
+        v += dfs(a, b, c + 1, d, x, y) * (13 - c) / rst;
+    if (d < 13) //方块有剩余，可能选出的是方块
+        v += dfs(a, b, c, d + 1, x, y) * (13 - d) / rst;
+
+    //如果小王没有被选出
+    if (x == 0)
+        v += min(min(dfs(a, b, c, d, 1, y), dfs(a, b, c, d, 2, y)), min(dfs(a, b, c, d, 3, y), dfs(a, b, c, d, 4, y))) / rst;
+
+    //如果大王没有被选出
+    if (y == 0)
+        v += min(min(dfs(a, b, c, d, x, 1), dfs(a, b, c, d, x, 2)), min(dfs(a, b, c, d, x, 3), dfs(a, b, c, d, x, 4))) / rst;
+
+    return f[a][b][c][d][x][y] = v;
+}
+
+int main() {
+    cin >> A >> B >> C >> D;
+    //① 终点状态不唯一，起点是唯的的，所以以起点为终点，以终点为起点,反着推
+    //② AcWing 217. 绿豆蛙的归宿　需要建图，本题不用建图
+    double res = dfs(0, 0, 0, 0, 0, 0); //四种花色、大小王都还没有被抽取
+
+    if (res > INF / 2) //因为是浮点数，不能用等号判断是不是相等，简单的办法就是INF/2
+        puts("-1.000");
+    else
+        printf("%.3f\n", res);
+    return 0;
+}

TangDou/AcWing_TiGao/T5/QiWang/218_dp.cpp

@@ -0,0 +1,48 @@
+#include <bits/stdc++.h>
+using namespace std;
+const int INF = 0x3f3f3f3f;
+const int N = 15;
+double f[N][N][N][N][5][5];
+int a, b, c, d;
+int main() {
+    memset(f, -1, sizeof f);
+    cin >> a >> b >> c >> d;
+
+    for (int i = 13; i >= 0; i--)
+        for (int j = 13; j >= 0; j--)
+            for (int k = 13; k >= 0; k--)
+                for (int w = 13; w >= 0; w--)
+                    for (int x = 4; x >= 0; x--)
+                        for (int y = 4; y >= 0; y--) {
+                            double &v = f[i][j][k][w][x][y];
+                            if (i + (x == 1) + (y == 1) >= a && j + (x == 2) + (y == 2) >= b
+                                && k + (x == 3) + (y == 3) >= c && w + (x == 4) + (y == 4) >= d) {
+                                v = 0;
+                                continue;
+                            }
+
+                            v = 1;
+                            int sum = i + j + k + w + (x != 0) + (y != 0);
+                            if (i < 13) v += f[i + 1][j][k][w][x][y] * (13 - i) / (54 - sum);
+                            if (j < 13) v += f[i][j + 1][k][w][x][y] * (13 - j) / (54 - sum);
+                            if (k < 13) v += f[i][j][k + 1][w][x][y] * (13 - k) / (54 - sum);
+                            if (w < 13) v += f[i][j][k][w + 1][x][y] * (13 - w) / (54 - sum);
+                            if (x == 0) {
+                                double t = INF;
+                                for (int u = 1; u <= 4; u++) t = min(t, f[i][j][k][w][u][y] / (54 - sum));
+                                v += t;
+                            }
+                            if (y == 0) {
+                                double t = INF;
+                                for (int u = 1; u <= 4; u++) t = min(t, f[i][j][k][w][x][u] / (54 - sum));
+                                v += t;
+                            }
+                        }
+
+    if (f[0][0][0][0][0][0] > 54)
+        printf("-1.000");
+    else
+        printf("%.3lf", f[0][0][0][0][0][0]);
+
+    return 0;
+}