uva10917 dij单源最短路预处理+构造新图（DAG）+求图上路径数

//uva10917 dij单源最短路预处理+构造新图（DAG）+求图上路径数
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<cmath>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<map>
#define maxn 1100
#define INF 100000000
using namespace std;

vector<int>G[maxn];
int d[maxn];//DAG上dfs记忆化，存储i到终点的路径数
struct Edge
{
    int u,v,dis;
};
struct Node
{
    int d,u;
    bool operator<(const Node &x)const{
        return d>x.d;
    }
};
struct Dijkstra
{
    int n,m;
    vector<Edge>edge;
    vector<int>G[maxn];
    bool vis[maxn];
    int d[maxn],p[maxn];

    void init(int n)
    {
        this->n=n;
        edge.clear();
        for(int i=0;i<=n;i++) G[i].clear();
    }

    void add(int u,int v,int c){
        edge.push_back((Edge){u,v,c});
        m=edge.size();
        G[u].push_back(m-1);
    }

    void dij(int s)
    {
        memset(vis,0,sizeof(vis));
        for(int i=0;i<=n;i++) d[i]=INF;
        d[s]=0;
        priority_queue<Node>Q;
        Q.push((Node){0,s});
        while(!Q.empty()){
            Node x=Q.top();Q.pop();
            int u=x.u;
            if (vis[u]) continue;
            vis[u]=true;
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e=edge[G[u][i]];
                if (d[e.v]>d[u]+e.dis){
                    d[e.v]=d[u]+e.dis;
                    p[e.v]=G[u][i];
                    Q.push((Node){d[e.v],e.v});
                }
            }
        }
    }
}Dij1;

int nextint(){int x;scanf("%d",&x);return x;}

int n,m,ans;

int dfs(int st)//DAG上dp，记忆化搜索
{
    int ans=0;
    if (d[st]!=-1) return d[st];
    for(int i=0;i<G[st].size();i++) ans+=dfs(G[st][i]);
    return d[st]=ans;
}
void read(int n,int m)
{
    for(int i=0;i<m;i++)
    {
        int u,v,c;
        u=nextint();v=nextint();c=nextint();
        Dij1.add(u,v,c);
        Dij1.add(v,u,c);
    }
    Dij1.dij(2);
}
void solve(int n,int m)
{
    for(int i=1;i<=n;i++) G[i].clear();
    //建图,注意是枚举每条边，不可能构造出新的边~
    for(int i=0;i<Dij1.m;i++)
    {
        Edge e=Dij1.edge[i];
        int u=e.u,v=e.v;
        if (Dij1.d[u]<Dij1.d[v]) G[v].push_back(u);
    }
    for(int i=1;i<=n;i++) d[i]=-1;
    d[2]=1;
    dfs(1);
    printf("%d
",d[1]);
}
int main()
{
    int n,m;
    while(cin>>n)
    {
        if (n==0) break;
        cin>>m;
        Dij1.init(n);
        read(n,m);
        solve(n,m);
    }
    return 0;
}