[HAOI2012] 道路

这道题首先我们应该考虑到的是，因为我们最短路的起点和终点都不知道，所以我么应该枚举起点，然后跑最短路

我们枚举起点之后，每次跑最短路，都可以构造出一个最短路图（由所有在最短路上的边构成）

判断一条边在不在最短路图的方法是如果$dis[v]=dis[u]+length(u,v)$，那么他在最短路图上

那么我们接下来要枚举最短路图上的每条边，对于一条边$(u,v)$，我们需要处理出的是从$s$到$u$的最短路图上的路径条数，和$v$到每个点的最短路图上的路径图，因为最短路图是一个DAG，所以我们可以通过拓扑排序上$dp$来解决

对于第一个问题，很好解决

第二个问题，由于不知道终点，不太好处理，但是我们知道起点啊！所以我们可以通过建立反图来解决

但是建反图不好建怎么办？

我们可以考虑，我们往下转移的时候，下面的点的拓扑序一定比这个点要大，所以我们可以按拓扑序逆序处理就好了

还有一个问题：为什么这题会卡掉$dijkstra$呢

我们看$dijsktra$的复杂度，这道题因为要枚举起点，复杂度是$O(nm\log m)$，显然是容易被卡的

为什么$spfa$没有$spfa$呢？

因为我们要从每个点都跑一边最短路啊，$spfa$均摊是$O(km)$啊，出题人显然不会花时间在这上面为了卡掉$spfa$，而且数据很难构造

代码啦：

#include <bits/stdc++.h>
using namespace std;

# define Rep(i,a,b) for(int i=a;i<=b;i++)
# define _Rep(i,a,b) for(int i=a;i>=b;i--)
# define RepG(i,u) for(int i=head[u];~i;i=e[i].next)

typedef long long ll;

const int N=10005;
const int mod=1e9+7;

template <typename T> void read(T &x){
    x=0;int f=1;
    char c=getchar();
    for(;!isdigit(c);c=getchar())if(c=='-')f=-1;
    for(;isdigit(c);c=getchar())x=(x<<1)+(x<<3)+c-'0';
    x*=f;
}

int n,m;
int head[N],cnt;
int tpx[N],inde[N],tot;
int dis[N];
ll f[N],g[N];
bool inq[N],is[N];
ll ans[N];

struct Edge{
    int from,to,next,w;
}e[N<<1];

void add(int x,int y,int c){
    e[++cnt]=(Edge){x,y,head[x],c},head[x]=cnt;
}

void spfa(int s){
    memset(dis,0x3f,sizeof(dis));
    queue<int> q;
    q.push(s);
    dis[s]=0;
    inq[s]=true;
    while(!q.empty()){
        int u=q.front();q.pop();
        inq[u]=false;
        RepG(i,u){
            int v=e[i].to;
            if(dis[v]>dis[u]+e[i].w){
                dis[v]=dis[u]+e[i].w;
                if(!inq[v])inq[v]=true,q.push(v);
            }
        }
    }
    Rep(i,1,m)
        if(dis[e[i].from]+e[i].w==dis[e[i].to])is[i]=true,inde[e[i].to]++;
        else is[i]=false;
}

void topo(){
    queue<int> q;
    Rep(i,1,n)if(!inde[i])q.push(i);
    tot=0;
    while(!q.empty()){
        int u=q.front();q.pop();
        tpx[++tot]=u;
        RepG(i,u){
            if(!is[i])continue;
            int v=e[i].to;
            inde[v]--;
            if(!inde[v])q.push(v);
        }
    }
}

void update(int s){
    memset(f,0,sizeof(f));
    memset(g,0,sizeof(g));
    f[s]=1;
    Rep(i,1,tot){
        int u=tpx[i];
        RepG(i,u){
            if(!is[i])continue;
            int v=e[i].to;
            f[v]+=f[u];
        }
    }
    _Rep(i,tot,1){
        int u=tpx[i];
        g[u]++;
        RepG(i,u){
            if(!is[i])continue;
            int v=e[i].to;
            g[u]+=g[v];
        }
    }
    Rep(i,1,m)
        if(is[i])
            ans[i]=(ans[i]+1ll*f[e[i].from]*g[e[i].to])%mod;
}

int main()
{
    memset(head,-1,sizeof(head));
    read(n),read(m);
    Rep(i,1,m){
        int x,y,c;
        read(x),read(y),read(c);
        add(x,y,c);
    }
    Rep(i,1,n){
        spfa(i);
        topo();
        update(i);
    }
    Rep(i,1,m)printf("%lld\n",ans[i]);
    return 0;
}