【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("
")
#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 = 505;
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 = -1;
    for(int v=0; 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=0; v<n; v++){
        if(G[s][v] != INF && v != s){
            dis[v] = G[s][v];//一步直达
            path[v] = s;
            pathNum[v] = 1;
            sum[v] = a[s] + a[v];
        }
    }
    path[s] = -1;
    pathNum[s] = 1;
    vis[s] = 1;
    sum[s] = a[s];
    dis[s] = 0;
    while(1){
        int u = shortest();//select the next vertex
        if(u == -1) break;//no vertex left
        //cout << "choose " << u << endl;
        vis[u] = 1;
        for(int v=0; 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=0; u<n; u++){
        for(int v=0; v<n; v++){
            G[u][v] = INF;
        }
        G[u][u] = 0;
        dis[u] = INF;
    }
    CLEAR(path, -1);
    CLEAR(pathNum, 0);
    CLEAR(sum, 0);
    CLEAR(vis, 0);
}

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
", 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() > 1){
        printf("%d ", sta.top());
        sta.pop();
    }
    printf("%d", sta.top());
    return 0;
}