【题解】绿豆蛙的归宿

绿豆蛙的归宿

【题目描述】

给出一个有向无环的连通图，起点为 $1$ 终点为 $N$ ，每条边都有一个长度。绿豆蛙从起点出发，走向终点。数据保证从起点出发能够达到图中所有点，图中所有点都能够到底终点。

到达每一个顶点时，如果有 $K$ 条离开该点的道路，绿豆蛙可以选择任意一条道路离开该点，并且走向每条路的概率为 $\frac{1}{K}$ 。

现在绿豆蛙想知道，从起点走到终点的所经过的路径总长度期望是多少？

【输入】

第一行: 两个整数 $N,M$ ，代表图中有 $N$ 个点、$M$ 条边。

第二行到第 $1+M$ 行: 每行 $3$ 个整数 $a、b、c$ ，代表从 $a$ 到 $b$ 有一条长度为 $c$ 的有向边。

【输出】

从起点到终点路径总长度的期望值，四舍五入保留两位小数。

【样例输入】

4 4
1 2 1
1 3 2
2 3 3
3 4 4

【样例输出】

7.00

【数据范围】

对于 $100\%$ 的数据 $N\le 100000，M\le 2\times N$ 。

【算法分析】

可以考虑顺推和逆推。

顺推

设 $f[x]$ 表示结点 $1$ 走到结点 $x$ 所经过的路径的期望长度。显然 $f[1]=0$ ，最后要求 $f[n]$ 。

设从 $x$ 出发，有 $k$ 条路径，分别到达 $y_1,y_2...y_k$，边长分别为 $z_1,z_2...z_k$ 。

同时，设 $g[x]$ 表结点 $1$ 走到 $x$ 的概率，根据期望的定义与性质，有：

$f[y_i]=(f[x]+z_i\times g[x])/k$

$g[y_i]=g[x]/k$

这只是 $x$ 对 $y_i$ 的贡献，$y_i$ 可能存在多个前驱，需要将所有的期望相加，得到最终的 $f[y_i]$ 。

求解时，按照拓扑序进行求解，时间复杂度为 $O(N+M)$ 。

逆推

设 $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)$ 。

$f[y_i]$ 根据设定已经确定是能够到达 $n$ 点了，概率为 $1$ 。

$f[n]$ 已知，需要求解 $f[1]$ ，建立反向图，按照拓扑序求解。

【参考程序】

顺推

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m;
int head[N],tot,din[N],dout[N];
struct node
{
	int nxt,to,w;
}edge[2*N];
long double f[N],g[N];
queue<int> q;
void Add(int x,int y,int z)
{
	edge[++tot].nxt=head[x];
	head[x]=tot;
	edge[tot].to=y;
	edge[tot].w=z;
}
void solve()
{
	f[1]=0.0;
	g[1]=1.0; 
	q.push(1);
	while(q.size())
	{
		int x=q.front();q.pop();
		for(int i=head[x];i!=-1;i=edge[i].nxt)
		{
			int y=edge[i].to;
			long double z=edge[i].w;                               
			f[y]+=(f[x]+z*g[x])/dout[x]; 
			g[y]+=g[x]/dout[x];
			din[y]--;
			if(din[y]==0) q.push(y); 
		}
	}
}
int main()
{
	memset(head,-1,sizeof(head));
	scanf("%d%d",&n,&m);
	int x,y,z;
	for(int i=1;i<=m;i++)	
	{
		scanf("%d%d%d",&x,&y,&z);
		Add(x,y,z);					
		din[y]++;					//入度 
		dout[x]++;					//出度 
	}
	solve(); 
	printf("%.2Lf\n",f[n]);
	return 0;
} 

逆推

#include<bits/stdc++.h>
using namespace std;
const int N=100010;
int n,m;
int head[N],tot,din[N],dcount[N];
struct node
{
	int nxt,to,w;
}edge[2*N];
double f[N];
queue<int> q;
void Add(int x,int y,int z)
{
	edge[++tot].nxt=head[x];
	head[x]=tot;
	edge[tot].to=y;
	edge[tot].w=z;
}
void solve()
{
	f[n]=0;
	q.push(n);
	while(q.size())
	{
		int x=q.front();q.pop();
		for(int i=head[x];i!=-1;i=edge[i].nxt)
		{
			int y=edge[i].to;
			double z=edge[i].w;                                
			f[y]=f[y]+(f[x]+z)/dcount[y];
			din[y]--;
			if(din[y]==0) q.push(y);
		}
	}
}
int main()
{
	memset(head,-1,sizeof(head));
	scanf("%d%d",&n,&m);
	int x,y,z;
	for(int i=1;i<=m;i++)	
	{
		scanf("%d%d%d",&x,&y,&z);
		Add(y,x,z);					//反向图 
		din[x]++;					//入度 
		dcount[x]=din[x];			//入度数量 
	}
	solve(); 
	printf("%.2lf\n",f[1]);
	return 0;
}