|
|
##[$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
|
|
|
```
|
|
|
|
|
|
### 二、数学期望
|
|
|
|
|
|
**[视频讲解 数学期望及性质](https://www.ixigua.com/6978816201023554061)**
|
|
|
|
|
|
**[参考题解](https://www.acwing.com/solution/content/63508/)**
|
|
|
|
|
|
首先明白一点：到达某个结果的期望值 = 这个结果 * 从起始状态到这个状态的概率
|
|
|
|
|
|
$Q:$什么意思呢？
|
|
|
|
|
|
如图：
|
|
|
<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−>3:E_1=2×\frac{1}{2}=1$
|
|
|
|
|
|
路径$2$. $\displaystyle 1−>2−>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'><h3>总结：概率是叠乘的</h3></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 = 2 * N;
|
|
|
|
|
|
//邻接表
|
|
|
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 j = e[i]; //此边，一端是t，另一端是j
|
|
|
//此边边条w[i]
|
|
|
f[j] += (f[u] + w[i] * g[u]) / out[u];
|
|
|
g[j] += g[u] / out[u]; // p[j]也需要概率累加
|
|
|
//拓扑序的标准套路
|
|
|
in[j]--;
|
|
|
if (!in[j]) q.push(j);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
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 j = e[i];
|
|
|
f[j] += (f[u] + w[i]) / g[j];
|
|
|
in[j]--;
|
|
|
if (in[j] == 0) q.push(j);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
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;
|
|
|
}
|
|
|
``` |
