'commit'

TangDou/AcWing_TiGao/T5/QiWang/217.md

@@ -1,7 +1,7 @@
 ##[$AcWing$ $217$. 绿豆蛙的归宿](https://www.acwing.com/problem/content/description/219/)
 
 ### 一、题目描述
-给出一个有向无环的连通图，起点为 $1$ ，终点为 $N$，每条边都有一个长度。
+给出一个 **有向无环的连通图**，起点为 $1$ ，终点为 $N$，每条边都有一个长度。
 
 数据保证从起点出发能够到达图中所有的点，图中所有的点也都能够到达终点。
 
@@ -37,6 +37,13 @@ $1≤N≤10^5,1≤M≤2N$
 ```
 
 ### 二、数学期望
+期望的起点一般都是唯一的，终点一般都是不唯一的。
+
+所以，一般我们喜欢从终点倒推。
+
+$f(i)$：从$i$跳到$N$的期望长度。边界$f(N)=0$
+答案：$f(1)$
+
 
 首先明白一点：到达某个结果的期望值 = 这个结果 * 从起始状态到这个状态的概率
 
@@ -60,145 +67,55 @@ $1≤N≤10^5,1≤M≤2N$
 ③ 所有贡献值累加和就是期望
 </h5></font> 
 
+#### 期望的线性性质
+$$\large E(aX+bY)=aE(X)+bE(Y)$$
 
-本题有 **正推** 和 **倒推** 两种写法:
+根据本题题意我们可以进行递推
 
-#### 正推法
-<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>
+$f(i)$: 从 $i$ 跳到 $N$ 的期望长度
+边界: $f(N)=0$
+所求的答案: $f(1)$
+则有如下递推式：
 
-设：
-- $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$
+$\large f(i)=E(\frac{1}{k}(w_1+x_1)+\frac{1}{k}(w_2+x_2)+⋯+\frac{1}{k}(w_k+x_k)) \\
+=E(\frac{1}{k}(w_1+x_1))+E(\frac{1}{k}(w_2+x_2))+⋯+E(\frac{1}{k}(w_k+x_k))\\ 
+=\frac{1}{k}((w_1+E(x_1))+(w_2+E(x_2))+⋯+(w_k+E(x_k))) \\
+=\frac{1}{k}((w_1+f(i_1))+(w_2+f(i_2))+⋯+(w_k+f(i_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 n, m;
 int h[N], e[M], ne[M], w[M], idx;
+int out[N];
+double f[N];
+
 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);
-        }
+double dfs(int u) {
+    if (f[u] >= 0) return f[u]; // 如果u点计算过，记忆化搜索返回结果值
+    f[u] = 0;                   // 初始化为0，准备开始填充
+    for (int i = h[u]; ~i; i = ne[i]) {
+        int j = e[i];
+        f[u] += (w[i] + dfs(j)) / out[u]; // 看推的公式
     }
+    return f[u];
 }
-
 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]; // 入度数量
+        out[a]++;
     }
-    topsort();
-    printf("%.2lf\n", f[1]);
+    memset(f, -1, sizeof f);
+    printf("%.2lf\n", dfs(1));
     return 0;
 }
 ```

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

@@ -0,0 +1,35 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+const int N = 1e5 + 10, M = N << 1;
+
+int n, m;
+int h[N], e[M], ne[M], w[M], idx;
+int out[N];
+double f[N];
+
+void add(int a, int b, int c) {
+    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
+}
+double dfs(int u) {
+    if (f[u] >= 0) return f[u]; // 如果u点计算过，记忆化搜索返回结果值
+    f[u] = 0;                   // 初始化为0，准备开始填充
+    for (int i = h[u]; ~i; i = ne[i]) {
+        int j = e[i];
+        f[u] += (w[i] + dfs(j)) / out[u]; // 看推的公式
+    }
+    return f[u];
+}
+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]++;
+    }
+    memset(f, -1, sizeof f);
+    printf("%.2lf\n", dfs(1));
+    return 0;
+}