bzoj2750 [HAOI2012]Road dij+拓扑排序

Description

---

C国有n座城市，城市之间通过m条单向道路连接。一条路径被称为最短路，当且仅当不存在从它的起点到终点的另外一条路径总长度比它小。两条最短路不同，当且仅当它们包含的道路序列不同。我们需要对每条道路的重要性进行评估，评估方式为计算有多少条不同的最短路经过该道路。现在，这个任务交给了你。

Solution

---

考虑枚举最短路的起点建最短路dag。记f[i]为从起点到i的路径数量，g[i]为以i为起点的路径数量，显然一条边(x,y)在当前点作为起点时的贡献为f[y]*g[x]
然后拓扑排序一波正着做倒着做就做完了。注意到我们并不需要把dag建出来

在洛谷上卡卡卡开了O2才过，bzoj数据大概比较弱

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <queue>
#define rep(i,st,ed) for (register int i=st;i<=ed;++i)
#define drp(i,st,ed) for (register int i=st;i>=ed;--i)
#define fill(x,t) memset(x,t,sizeof(x))

typedef long long LL;
const int MOD=1000000007;
const int INF=0x7fffffff;
const int N=1505;
const int E=5005;

struct edge {int x,y,w,next; bool used;} e[E];
struct data {
    int fi,se;

    bool operator <(data b) const {
        return fi<b.fi;
    }
} ;

int ind[N],f[N],g[N],queue[N];
int dis[N],ls[N],edCnt;
LL ans[E];

bool vis[N];

void mod(int &x) {
    (x>=MOD)?(x-=MOD):(0);
}

void top_sort(int n) {
    int head=1,tail=0;
    rep(i,1,n) if (!ind[i]&&dis[i]!=dis[0]) {
        queue[++tail]=i;
    }
    for (;head<=tail;) {
        int now=queue[head++];
        for (int i=ls[now];i;i=e[i].next) {
            if (e[i].used) {
                if (!(--ind[e[i].y])) {
                    queue[++tail]=e[i].y;
                }
            }
        }
    }
    rep(i,0,n) f[i]=0,g[i]=0;
    g[queue[1]]=1;
    rep(ti,1,tail) { int now=queue[ti];
        for (int i=ls[now];i;i=e[i].next) {
            if (e[i].used) mod(g[e[i].y]+=g[now]);
        }
    }
    drp(ti,tail,1) { int now=queue[ti];
        f[now]=1;
        for (int i=ls[now];i;i=e[i].next) {
            if (e[i].used) mod(f[now]+=f[e[i].y]);
        }
    }
    rep(i,1,edCnt) if (e[i].used) {
        ans[i]=(ans[i]+1LL*g[e[i].x]*f[e[i].y]%MOD)%MOD;
    }
}

int read() {
    int x=0,v=1; char ch=getchar();
    for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):(v),ch=getchar());
    for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
    return x*v;
}

void add_edge(int x,int y,int w) {
    e[++edCnt]=(edge) {x,y,w,ls[x]}; ls[x]=edCnt;
}

void dijk(int st,int n) {
    rep(i,0,n) {
        dis[i]=INF;
        vis[i]=0; ind[i]=0;
    }
    dis[st]=0;
    std:: priority_queue <data> heap;
    heap.push((data){0,st});
    for (;!heap.empty();) {
        data top=heap.top(); heap.pop();
        if (vis[top.se]) continue; vis[top.se]=true;
        for (int i=ls[top.se];i;i=e[i].next) {
            if (e[i].w-top.fi<dis[e[i].y]) {
                dis[e[i].y]=e[i].w-top.fi;
                heap.push((data){-dis[e[i].y],e[i].y});
            }
        }
    }
}

int main(void) {
    int n=read(),m=read();
    rep(i,1,m) {
        int x=read(),y=read(),w=read();
        add_edge(x,y,w);
    }
    rep(i,1,n) {
        dijk(i,n);
        rep(j,1,edCnt) if (dis[e[j].x]+e[j].w==dis[e[j].y]) {
            e[j].used=1; ++ind[e[j].y];
        } else e[j].used=0;
        top_sort(n);
    }
    rep(i,1,edCnt) printf("%lld\n", ans[i]);
    return 0;
}