【PAT】PAT A-1003 Emergency【无向图最短路】【Dijkstra算法】

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input

Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (<= 500) – the number of cities (and the cities are numbered from 0 to N-1), M – the number of roads, C1 and C2 – the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c1, c2 and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C1 to C2.

Output

For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2, and the maximum amount of rescue teams you can possibly gather.
All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.

Sample Input:

5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1

Sample Output:

2 4

题目大意

n个城市之间有m条路，每个城市有若干救援部队，求从c1城市到c2城市最短路线的个数，以及最短路线中能召集的最大的救援部队数之和。

思路

最短路线使用Dijkstra算法求出，进行细微的改进，支持多条路径。本题不需要打印出路径只需要打印出路线条数和最大的救援部队之和，所以在原算法的基础上做了一些改进。也可以先使用经典的Dijkstra算法，再使用dfs遍历最小路径树得出路线数和最大的救援部队之和。
在Dijkstra算法中，我们可以显然得出，下一轮被放松的顶点一定是上一轮被放松过的顶点。所以使用一个优先队列来存储上一轮被放松的结点可以提高算法的效率。遍历一遍所有结点的时间复杂度是O(n)，而使用优先队列获得最小值仅需要O(logn)。

代码

#include 
#include 
#include 
#include 
using namespace std;
typedef pair<int, int> Edge;
struct Node{
    int v;
    int dist;
    Node(int v, int dist) : v(v), dist(dist){};
    bool operator< (const Node either)const{
        return dist> either.dist;
    }
};
const int MAX_N = 510;
const int INF = 99999999;
vector<Edge> graph[MAX_N];
int team[MAX_N], road[MAX_N], maxTeam[MAX_N], distTo[MAX_N];
bool marked[MAX_N];
int main() {
    int n, m, c1, c2;
    scanf("%d %d %d %d", &n, &m, &c1, &c2);
    for(int i = 0; i < n; i++){
        scanf("%d", &team[i]);
    }
    int v, w, l;
    for(int i = 0; i < m; i++){
        scanf("%d %d %d", &v, &w, &l);
        graph[v].push_back(Edge(w, l));
        graph[w].push_back(Edge(v, l));
    }
    fill(maxTeam, maxTeam + MAX_N, 0);
    fill(road, road + MAX_N, 0);
    fill(distTo, distTo + MAX_N, INF);
    fill(marked, marked + MAX_N, false);
    
    // 初始化起点
    distTo[c1] = 0;
    road[c1] = 1;
    maxTeam[c1] = team[c1];
    priority_queue<Node> q;
    q.push(Node(c1, 0));
    while (!q.empty()) {
        const int v = q.top().v;
        q.pop();
        // 遇到终点则退出循环
        if(v == c2) break;
        
        
        // 将顶点标记为已访问
        marked[v] = true;
        
        // 遍历该顶点的各条未被访问的边
        vector<Edge> edges = graph[v];
        int w, weight, cmp;
        for(Edge e : graph[v]){
            w = e.first;
            if(marked[w]) continue;
            weight = e.second;
            cmp = weight + distTo[v] - distTo[w];
            if(cmp < 0){
                // 找到一条更短的边，更新距离信息，初始化最大队伍数，起点到w的路线数等于起点到v的路线数
                distTo[w] += cmp;
                maxTeam[w] = maxTeam[v] + team[w];
                road[w] = road[v];
                // 将节点加入优先队列中
                q.push(Node(w, distTo[w]));
            }else if(cmp == 0){
                // 找到一条和已知路线相同长度的新路线， 更新最大队伍数，起点到w的路线数加上起点到v的路线数
                maxTeam[w] = max(maxTeam[w], maxTeam[v] + team[w]);
                road[w] += road[v];
            }
        }
    }
    printf("%d %d", road[c2], maxTeam[c2]);
    return 0;
}