UVa 10917 Dijkstra

本来就是水题一道。

题意：一个人要从点1去到点2，中间还有很多点和很多条边。问你如果他每次走的边(a,b)都满足：a点到目标点的最短距离<b点到目标点的最短距离，那么他从点1出发到点2总共有多少条路径。

思路：先用Dijkstra求最短路，然后创一个图，对于满足条件的边(a,b)就加一条有向边，由于是严格按照小于加的边，图中绝对没有环，是个DAG。接下来dp就行了。

dp[i]表示i点出发有多少条路径，dp[i]=sum(dp[j])。

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
const int maxn=1005;
const int INF=0x3f3f3f3f;
struct Edge{
    int from,to,dist;
};
struct HeapNode{
    int d,u;
    bool operator < (const HeapNode& rhs) const
    {
        return d>rhs.d;
    }
};
struct Dijkstra{
    int n,m;
    int d[maxn],p[maxn];
    bool done[maxn];
    vector<Edge> edges;
    vector<int> G[maxn];
    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++)G[i].clear();
        edges.clear();
    }
    void AddEdge(int from,int to,int dist)
    {
        edges.push_back((Edge){from,to,dist});
        m=edges.size();
        G[from].push_back(m-1);
    }
    void dijkstra(int s)
    {
        priority_queue<HeapNode> Q;
        int u;
        HeapNode x;
        for(int i=0;i<n;i++)d[i]=INF;
        d[s]=0;
        memset(done,0,sizeof(done));
        Q.push((HeapNode){0,s});
        while(!Q.empty()){
            x=Q.top();Q.pop();
            u=x.u;
            if(done[u])continue;
            done[u]=true;
            for(int i=0;i<G[u].size();i++){
            Edge& e=edges[G[u][i]];
                if(d[e.to] > d[e.from]+e.dist){
                    d[e.to]=d[e.from]+e.dist;
                    p[e.to]=G[u][i];
                    Q.push((HeapNode){d[e.to],e.to});
                }
            }
        }
    }
};
int n;
Dijkstra solver;
vector<int> Map[maxn];
int dp[maxn];
int dfs(int u)
{
    if(dp[u]!=-1) return dp[u];
    if(u==1) return dp[u]=1;
    int ret=0;
    for(int i=0;i<Map[u].size();i++)
        ret+=dfs(Map[u][i]);
    return dp[u]=ret;
}

int main()
{
    int m,a,b,c;
    while(~scanf("%d%d",&n,&m)&&n){
        solver.init(n);
        while(m--){
            scanf("%d%d%d",&a,&b,&c);
            a--;b--;
            solver.AddEdge(a,b,c);
            solver.AddEdge(b,a,c);
        }
        solver.dijkstra(1);
        for(int i=0;i<n;i++)Map[i].clear();
        for(int i=0;i<solver.m;i++){
            int &u=solver.edges[i].from;
            int &v=solver.edges[i].to;
            if(solver.d[u]>solver.d[v]) Map[u].push_back(v);
        }
        memset(dp,-1,sizeof(dp));
        printf("%d
",dfs(0));
    }
    return 0;
}