数学期望

数学期望

数学期望 - 绿豆蛙的归宿 - 洛谷 P4316

题目描述

给出张 n 个点 m 条边的有向无环图，起点为 1，终点为 n，每条边都有一个长度，并且从起点出发能够到达所有的点，所有的点也都能够到达终点。

绿豆蛙从起点出发，走向终点。 到达每一个顶点时，如果该节点有 k 条出边，绿豆蛙可以选择任意一条边离开该点，并且走向每条边的概率为 1 k frac{1}{k} k1​ 。现在绿豆蛙想知道，从起点走到终点的所经过的路径总长度期望是多少？

输入格式

输入的第一行是两个整数，分别代表图的点数 n 和边数 m。

第 2 到第 (m+1) 行，每行有三个整数 u, v, w，代表存在一条从 u 指向 v 长度为 w 的有向边。

输出格式

输出一行一个实数代表答案，四舍五入保留两位小数。

输入输出样例

输入 #1

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

输出 #1

7.00

分析:

数学期望: 一 个 离 散 性 随 机 变 量 的 数 学 期 望 是 试 验 中 每 次 可 能 的 结 果 乘 以 其 结 果 概 率 的 总 和 。 一个离散性随机变量的数学期望是试验中每次可能的结果乘以其结果概率的总和。 一个离散性随机变量的数学期望是试验中每次可能的结果乘以其结果概率的总和。

E ( x ) = ∑ w ∈ Ω X ( w ) P ( w ) E(x)=sum_{w∈Omega}X(w)P(w) E(x)=w∈Ω∑​X(w)P(w)

线性性质:

① 、 E ( a X + b Y ) = a E ( X ) + b E ( Y ) ①、E(aX+bY)=aE(X)+bE(Y) ①、E(aX+bY)=aE(X)+bE(Y)

② 、 E ( X Y ) = E ( X ) E ( Y ) ②、E(XY)=E(X)E(Y) ②、E(XY)=E(X)E(Y)

本题:

记 f [ i ] 表 示 从 i 到 终 点 n 的 期 望 长 度 . 记f[i]表示从i到终点n的期望长度. 记f[i]表示从i到终点n的期望长度.

从 u 到 j 的 可 能 的 结 果 为 f [ u ] + w u − > j , 概 率 为 1 k , 其 中 k 为 点 u 的 出 度 . 从u到j的可能的结果为f[u]+w_{u->j},概率为frac{1}{k},其中k为点u的出度. 从u到j的可能的结果为f[u]+wu−>j​,概率为k1​,其中k为点u的出度.

则 f [ j ] = ∑ ( f [ u ] + w u − > j ) × 1 k 则f[j]=sum(f[u]+w_{u->j})×frac{1}{k} 则f[j]=∑(f[u]+wu−>j​)×k1​

由 于 终 点 的 个 数 有 时 不 唯 一 , 我 们 习 惯 性 地 从 终 点 反 推 到 起 点 , 这 样 最 终 答 案 即 f [ 1 ] . 由于终点的个数有时不唯一,我们习惯性地从终点反推到起点,这样最终答案即f[1]. 由于终点的个数有时不唯一,我们习惯性地从终点反推到起点,这样最终答案即f[1].

方法一:记忆化搜索

递 归 实 现 , 则 靠 近 n 的 点 先 被 算 出 , 递归实现,则靠近n的点先被算出, 递归实现,则靠近n的点先被算出,

倒 推 时 , 相 当 于 从 从 j 走 到 u , 即 f [ u ] + = ( w [ i ] + f [ j ] ) × 1 k , f [ j ] 由 递 归 函 数 先 递 归 计 算 再 返 回 . 倒推时,相当于从从j走到u,即f[u]+=(w[i]+f[j])×frac{1}{k},f[j]由递归函数先递归计算再返回. 倒推时,相当于从从j走到u,即f[u]+=(w[i]+f[j])×k1​,f[j]由递归函数先递归计算再返回.

方法二:拓扑图上DP

反 向 建 图 , 从 n 到 1 按 照 拓 扑 序 递 推 即 可 . 反向建图,从n到1按照拓扑序递推即可. 反向建图,从n到1按照拓扑序递推即可.

注 意 , 只 有 当 点 j 的 入 度 为 0 时 , f [ j ] 才 被 计 算 完 全 , 这 时 才 能 够 将 点 j 入 队 . 注意,只有当点j的入度为0时,f[j]才被计算完全,这时才能够将点j入队. 注意,只有当点j的入度为0时,f[j]才被计算完全,这时才能够将点j入队.

而 记 忆 化 搜 索 不 需 要 考 虑 这 个 问 题 , 因 为 从 j 会 向 所 有 相 邻 的 点 扩 展 , 优 先 计 算 j 的 邻 点 的 期 望 值 . 而记忆化搜索不需要考虑这个问题,因为从j会向所有相邻的点扩展,优先计算j的邻点的期望值. 而记忆化搜索不需要考虑这个问题,因为从j会向所有相邻的点扩展,优先计算j的邻点的期望值.

记忆化搜索：
代码：

#include<cstdio>
#include<cstring>
#include<algorithm>using namespace std;const int N=1e5+10, M=2*N;int n,m;
int e[M],ne[M],w[M],h[N],idx;
double f[N];
int dout[N];void add(int a,int b,int c)
{e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}double dp(int u)
{if(f[u]>=0) return f[u];f[u]=0;for(int i=h[u];~i;i=ne[i]){int j=e[i];f[u]+=(w[i]+dp(j))/dout[u];}return f[u];
}int main()
{scanf("%d%d",&n,&m);int a,b,c;memset(h,-1,sizeof h);while(m--){scanf("%d%d%d",&a,&b,&c);add(a,b,c);dout[a]++;}memset(f,-1,sizeof f);printf("%.2lfn",dp(1));return 0;
}

按拓扑序ＤＰ
代码：

#include<cstdio>
#include<queue>
#include<cstring>
#include<algorithm>using namespace std;const int N=1e5+10, M=2*N;int n,m;
int e[M],ne[M],w[M],h[N],idx;
double f[N];
int dout[N], out[N];void add(int a,int b,int c)
{e[idx]=b,w[idx]=c,ne[idx]=h[a],h[a]=idx++;
}double dp(int u)
{   queue<int> Q;Q.push(n);f[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])/dout[j];out[j]--;if(!out[j]) Q.push(j);}}return f[1];
}int main()
{scanf("%d%d",&n,&m);int a,b,c;memset(h,-1,sizeof h);while(m--){scanf("%d%d%d",&a,&b,&c);add(b,a,c);dout[a]++;out[a]++;}printf("%.2lfn",dp(1));return 0;
}