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

DAG上的期望DP与拓扑排序

最新推荐文章于 2022-06-22 02:57:34 发布

原创最新推荐文章于 2022-06-22 02:57:34 发布 · 288 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#期望DP #拓扑排序 #前向星

ACM--DP 同时被 2 个专栏收录

10 篇文章

订阅专栏

ACM--拓扑排序

1 篇文章

订阅专栏

本文探讨了在有向无环图(DAG)上进行期望动态规划(Expectation DP)的方法，通过逆向和正向建图分别解决从任意节点到达目标节点的期望步数和期望花费问题，利用拓扑排序进行高效求解。

例题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;
}