uva10817 dijkstra

大白书P330

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string.h>
#include <vector>
#include <queue>
using namespace std;
const int maxn = +;
const int INF = ;
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;
   vector<Edge> edges;
   vector<int>G[maxn];
   bool done[maxn];
   int d[maxn];
   int p[maxn];
   void inti(int n){
       this->n=n;
       for(int i=; i < n; ++i)
        G[i].clear();
       edges.clear();
   }
   void AddEdge(int from, int to, int dist){
       edges.push_back((Edge){from,to,dist});
       int m =edges.size();
       G[from].push_back(m-);
   }
   void dijkstra(int s){
      priority_queue<HeapNode> Q;
      for(int i=; i<n; i++) d[i]=INF;
      d[s] = ;
      memset(done, false,sizeof(done));
      Q.push((HeapNode){,s});
      while(!Q.empty()){
          HeapNode x =Q.top();Q.pop();
          int u =x.u;
          if(done[u])continue;
          done[u] =true;
          for(int i=; i<G[u].size(); ++i){
              Edge &e = edges[G[u][i]];
              if(d[e.to]>d[u]+e.dist){
                 d[e.to] = d[u] +e.dist;
                 p[e.to]  = G[u][i];
                 Q.push((HeapNode){d[e.to],e.to});
              }
          }
      }
   }
}solve1;
vector<int> R[maxn];
int dp[maxn];
int dfs(int u){
    if(dp[u]!=-)  return dp[u];
    if(u==) return ;
    dp[u]=;
    for(int i = ; i<R[u].size(); i++){
         int v = R[u][i];
         dp[u]+=dfs(v);
    }
    return dp[u];
}
int main()
{
    int n,m;
    while(scanf("%d",&n)==&&n){
         scanf("%d",&m);
         solve1.inti(n);
         for(int i = ; i<m; ++i){
              int u,v,d;
              scanf("%d%d%d",&u,&v,&d); u--,v--;
              solve1.AddEdge(u,v,d);
              solve1.AddEdge(v,u,d);
         }
         solve1.dijkstra();
         for(int i = ; i<n; i++) R[i].clear();
         for(int i = ; i < solve1.edges.size(); ++i){
               int u=solve1.edges[i].from, v=solve1.edges[i].to;
               if(solve1.d[u]>solve1.d[v])
                 R[u].push_back(v);
         }
         memset(dp,-,sizeof(dp));
         printf("%d\n",dfs());
    }
    return ;
}