拓扑排序+期望dp解决DAG上的期望

例题1：luogu4316

倒推：

//luoguP4316.1 题意：n<1e5 m<2e5 DAG上到第N个点的期望步数 每次选择等概率前往下一个点,带边权
//一般期望倒着维护就不用乘贡献概率，正着就要乘贡献概率
//逆推版本：设dp[i]为i到点n的期望步数  
//dp[i]=sum_{}(dp[j]+eij)/ou(i)  //i->j  dp[n]=0,ans=dp[1]
//反向建图维护出dp即可
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100005;
const int maxe=200005;
int cnt=0;
int head[maxn];int to[maxe];int nxt[maxe];int w[maxe];
void add(int u,int v,int ww)
{
	cnt++;nxt[cnt]=head[u];
	head[u]=cnt; to[cnt]=v;
    w[cnt]=ww;
}
double dp[maxn];
int in[maxn];//入度(出度反向建图变成入度)
int tp[maxn];//入度（不变）
queue<int>q;

int main(){
    int n,m;scanf("%d %d",&n,&m);
    memset(head,-1,sizeof(head));
    for(int i=1;i<=m;i++){
        int x,y,ww;scanf("%d %d %d",&y,&x,&ww);//反向建图跑
        in[y]++;add(x,y,ww);
        tp[y]++;
    }  
    for(int i=n;i>=1;i--){
        if(in[i]==0)q.push(i);
    }
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head[u];i!=-1;i=nxt[i]){
            int v=to[i];int ww=w[i];
            dp[v]+=(double)(dp[u]+ww)/(double)tp[v];
            in[v]--;if(in[v]==0)q.push(v);
        }
    }
    for(int i=1;i<=n;i++)
        printf("%.2lf\n",dp[i]);

    system("pause");
    return 0;
}

正推：

//luoguP4316.2 DAG上到第N个点的期望步数
//一般期望倒着维护就不用乘贡献概率，正着就要乘贡献概率
//正推版本:设dp[i]为1到点i的期望步数
//dp[j]=sum(dp[i]+p[i]*eij)/out[i]; //i->j p[j]+=p[i]/out[i];
//正向建图即可
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100005;
const int maxe=200005;
int cnt=0;
int head[maxn];int to[maxe];int nxt[maxe];int w[maxe];
void add(int u,int v,int ww)
{
	cnt++;nxt[cnt]=head[u];
	head[u]=cnt; to[cnt]=v;
    w[cnt]=ww;
}
double dp[maxn];
double p[maxn];//经过某点的概率
int in[maxn];//入度
int ou[maxn];//入度（不变）
queue<int>q;

int main(){
    int n,m;scanf("%d %d",&n,&m);
    memset(head,-1,sizeof(head));
    for(int i=1;i<=m;i++){
        int x,y,ww;scanf("%d %d %d",&x,&y,&ww);
        in[y]++;add(x,y,ww);
        ou[x]++;
    }  
    for(int i=1;i<=n;i++){
        if(in[i]==0)q.push(i);
    }
    p[1]=1.0;
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head[u];i!=-1;i=nxt[i]){
            int v=to[i];int ww=w[i];
            dp[v]+=(double)(dp[u]+ww*p[u])/(double)ou[u];
            p[v]+=p[u]/ou[u];
            in[v]--;if(in[v]==0)q.push(v);
        }
    }
    //for(int i=1;i<=n;i++)
    printf("%.2lf\n",dp[n]);


    system("pause");
    return 0;
}

2019南京网络赛F.

对于g[i]，转移的花费是dp[i]，可以理解为接下来每一步都要多花dp[i]的花费

//2019南京网络赛D 期望DP+拓扑排序
//题意：DAG 起点1，终点n.每天可以等概率选择下一条路/留在原地  每次选择的花费是当前的天数，问到终点花费的期望
//思路：先维护出dp[i] i到n的期望天数 ，再维护出g[i]i到n的期望花费
//i->j dp[i]=sum{dp[j]+1   }/p + (dp[i]+1   )/p       p：i的选择个数
//i->j g[i] =sum{g[j]+dp[i]}/p + (dp[i]+g[i])/p       p：i的选择个数
//化简移项即可发现dp初始值为多少
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=100005;
const int maxe=200005;
int cnt=0;
int head[maxn];int to[maxe];int nxt[maxe];
void add(int u,int v)
{
	cnt++;nxt[cnt]=head[u];
	head[u]=cnt; to[cnt]=v;
}

int cnt2=0;
int head2[maxn];int to2[maxe];int nxt2[maxe];
void add2(int u,int v)
{
	cnt2++;nxt2[cnt2]=head2[u];
	head2[u]=cnt2; to2[cnt2]=v;
    
}

double dp[maxn];
int in[maxn];//入度(出度反向建图变成入度)
int tp[maxn];//入度（不变）

int in2[maxn];//入度(出度反向建图变成入度)
int tp2[maxn];//入度（不变）

double g[maxn];
queue<int>q;

int main(){
    int T;scanf("%d",&T);
    while(T--)
    {
    int n,m;scanf("%d %d",&n,&m);
    cnt=cnt2=0;
    memset(head,-1,sizeof(head));
    memset(head2,-1,sizeof(head2));
    memset(in,0,sizeof(in));
    memset(in2,0,sizeof(in2));
    memset(tp2,0,sizeof(tp2));
    memset(tp,0,sizeof(tp));
    for(int i=1;i<=m;i++){
        int x,y;scanf("%d %d",&y,&x);//反向建图跑
        in[y]++;add(x,y);tp[y]++;
        //swap(x,y);
        in2[y]++;add2(x,y);tp2[y]++;

    }  
    while(!q.empty())q.pop();
    for(int i=n;i>=1;i--){
        dp[i]=0;
        if(in[i]==0)q.push(i);
        else{
            dp[i]=(double)(1+tp[i])/(double)tp[i];
        }
    }
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head[u];i!=-1;i=nxt[i]){
            int v=to[i];
            dp[v]+=(double)(dp[u])/(double)tp[v];
            //g[v]+=(double)(dp[u]+g[u]+tp[v]+1)/(double)(tp[v]);
            in[v]--;if(in[v]==0)q.push(v);
        }
    }

    while(!q.empty())q.pop();
    for(int i=n;i>=1;i--){
        g[i]=0;
        if(in2[i]==0)q.push(i);
        else{
            g[i]=dp[i]*(double)(1+tp2[i])/(double)tp2[i];
        }
    }
    //g[n]=dp[n];
    while(!q.empty()){
        int u=q.front();q.pop();
        for(int i=head2[u];i!=-1;i=nxt2[i]){
            int v=to2[i];
            //dp[v]+=(double)(dp[u]+1+tp[v])/(double)tp[v];
            g[v]+=(double)(g[u])/(double)(tp2[v]);
            in2[v]--;if(in2[v]==0)q.push(v);
        }
    }
    printf("%.2lf\n",g[1]);

    }
    system("pause");
    return 0;
}