Dijkstra 路径统计 uva10917

/**
Dijkstra 算法模板

Dijkstra用法二：路径统计
可以枚举两点之间所有最短路，以及统计最短路的条数。首先，求出所有点到目标点的最短长度d[i],
然后从起点开始，只沿着d[i]=d[j]+dist[i][j]的边走。
统计路径：设f[i]表示从i点到目标点最短路的条数，则f[i]=sum{f[j]|d[i]=d[j]+dist[i][j]}.边界条件
为终点的f值为1.

这题，创建一个新的图，
当d[B]<d[A]时，在新图上连一条有向边A->B，则题目的目标就是求起点到终点有几条路径，动态规划
这题没什么wa点，很久没有这样一下子就过题了...

**/

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <queue>
#include <stack>
using namespace std;
const int INF=1<<27;
const int maxn=1005;

struct HeapNode//优先队列的节点
{
   int d,u;
   bool operator < (const HeapNode& rhs) const
   {
      return d>rhs.d;
   }
};

struct Edge
{
   int from,to,dist;
   Edge(int a,int b,int c)
   {
      from=a;
      to=b;
      dist=c;
   }
};

struct Dijkstra
{
   int n,m;//点数和边数
   vector<Edge> edges; //边列表
   vector<int> G[maxn]; //每个几点出发的边编号（从0开始编号）
   bool done[maxn]; //是否已经永久标号
   int d[maxn]; //s到各个点之间的距离
   int p[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)//求s到所有点的距离
   {
      priority_queue<HeapNode> Q;
      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())
      {
         HeapNode x=Q.top();
         Q.pop();
         int 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[u]+e.dist)
            {
               d[e.to]=d[u]+e.dist;
               p[e.to]=u;
               Q.push((HeapNode){d[e.to],e.to});
            }
         }
      }
   }
};

bool forest[1005][1005];
vector<int> g[1005];
int f[1005];

int cal(int x)
{
   int i;
   if(f[x]!=0) return f[x];
   for(i=0;i<g[x].size();i++)
   {
      f[x]+=cal(g[x][i]);
   }
   return f[x];
}

int main()
{
   int n,m,i,x,y,z,j;
   Dijkstra solver;
   while(scanf("%d",&n)!=EOF)
   {
      if(n==0) break;
      memset(forest,false,sizeof(forest));
      scanf("%d",&m);
      solver.init(n);
      for(i=0;i<m;i++)
      {
         scanf("%d%d%d",&x,&y,&z);
         x--;y--;
         solver.AddEdge(x,y,z);
         solver.AddEdge(y,x,z);
         forest[x][y]=forest[y][x]=true;
      }
      solver.dijkstra(1);

      for(i=0;i<n;i++) g[i].clear();
      for(i=0;i<n;i++)
         for(j=0;j<n;j++)
            if(forest[i][j] && solver.d[j]<solver.d[i])
               g[i].push_back(j);

      memset(f,0,sizeof(f));
      f[1]=1;
      printf("%d\n",cal(0));
   }
   return 0;
}