【PAT L2-001】最短路计数

给定一个无向带权网络，无负边，无重边和自环，每个顶点有一个正数权值。首先求特定原点s到终点d的最短路的个数；然后求所有最短路中顶点权值a[i]之和最大的那条，输出这条路径。

可用dijkstra算法求出所有最短路，用一个pathNum[u]数组记录从s到u的最短路的个数，查找链path[u]保存了到u为止使顶点权值a[i]之和最大的那条路径，sum[u]保存了这条路径的顶点权值和。

对于提交后的第3个测试点，注意更新新引入顶点u的邻居v的距离值dis[v]时，sum[v]无条件更新为sum[u]+a[v]，因为要先满足最短路这个条件，得到的顶点才有意义。最短路更新，则sum要重新计算。

参考了博客 http://blog.csdn.net/tc_to_top/article/details/51427223

 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <iostream>
 #include <algorithm>
 #include <stack>
 #include <cmath>
 #define RINT(V) scanf("%d", &(V))
 #define FREAD() freopen("in.txt", "r", stdin)
 #define REP(N) for(int i=0; i<(N); i++)
 #define REPE(N) for(int i=1; i<=(N); i++)
 #define PINT(N) printf("%d", (N))
 #define PSTR(S) printf("%s", S)
 #define RSTR(S) scanf("%s", S)
 #define pn() printf("\n")
 #define pb(V) push_back(V)
 #define CLEAR(A, V) memset((A), (V), sizeof(A))
 using namespace std;
 typedef long long ll;
 const int MAX_N = ;
 const int INF = 0x3fffffff;

 int n, m, s, d;
 int a[MAX_N];

 int V;
 int G[MAX_N][MAX_N];//邻接矩阵，无边是INF, 自己到自己是0
 int dis[MAX_N];//单源最短路数组
 int vis[MAX_N];
 int path[MAX_N], pathNum[MAX_N];
 int sum[MAX_N];

 int shortest(){
     int minn = INF;
     int rt = -;
     for(int v=; v<n; v++){
         if(v == s) continue;
         if(!vis[v] && dis[v] < minn){
             minn = dis[v];
             rt = v;
         }
     }
     return rt;
 }

 void dijkstra(){
     for(int v=; v<n; v++){
         if(G[s][v] != INF && v != s){
             dis[v] = G[s][v];//一步直达
             path[v] = s;
             pathNum[v] = ;
             sum[v] = a[s] + a[v];
         }
     }
     path[s] = -;
     pathNum[s] = ;
     vis[s] = ;
     sum[s] = a[s];
     dis[s] = ;
     while(){
         int u = shortest();//select the next vertex
         if(u == -) break;//no vertex left
         //cout << "choose " << u << endl;
         vis[u] = ;
         for(int v=; v<n; v++){//update priority
             if(vis[v]) continue;//只考虑Tk以外，即最短路尚未确定的点
             if(dis[v] > dis[u] + G[u][v]){
                 pathNum[v] = pathNum[u];
                 dis[v] = dis[u] + G[u][v];
                 path[v] = u;//记录前驱
                 sum[v] = sum[u] + a[v];//更新顶点上的权值和
             }else if(dis[v] == dis[u] + G[u][v]){//这部分是关键，同值不同解
                 //cout << "same " << u << endl;
                 pathNum[v] += pathNum[u];//|Tv| += |Tu| 这一步是关键
                 if(sum[v] < sum[u] + a[v]){
                     sum[v] = sum[u] + a[v];
                     path[v] = u;
                 }
             }
             //cout << "path[" << v << "] = " << path[v] << endl;
         }
     }
 }

 void init(){
     for(int u=; u<n; u++){
         for(int v=; v<n; v++){
             G[u][v] = INF;
         }
         G[u][u] = ;
         dis[u] = INF;
     }
     CLEAR(path, -);
     CLEAR(pathNum, );
     CLEAR(sum, );
     CLEAR(vis, );
 }

 int main()
 {
     FREAD();
     scanf("%d%d%d%d", &n, &m, &s, &d);
     init();
     REP(n) RINT(a[i]);
     REP(m){
         int u, v, w;
         scanf("%d%d%d", &u, &v, &w);
         G[u][v] = min(G[u][v], w);//其实没有重边
         G[v][u] = G[u][v];//邻接矩阵
     }

     dijkstra();//s为源, d为目的地
     printf("%d %d\n", pathNum[d], sum[d]);

     //输出路径
     stack<int> sta;
     int cur = d;
     sta.push(cur);
     while(cur != s){
         cur = path[cur];
         sta.push(cur);
     }
     while(sta.size() > ){
         printf("%d ", sta.top());
         sta.pop();
     }
     printf("%d", sta.top());
     return ;
 }