[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;
}