L2-001 紧急救援 (25 分)

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:

输入第一行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。

第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:

第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例:

4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2

输出样例:

2 60
0 1 3

思路

1. 这题属于最短路问题,可以用dijkstra算法来做,要点是要求最短路径的条数和能召集的最多救援队
2. 求最短路条数时类似于dp,当dis[nn]>dis[k]+dd,有min_n[nn]=min_n[k],而当dis[nn]==dis[k]+dd则是min_n[nn]+=min_n[k];
3. 求能召集的最多救援队时类似,当dis[nn]>dis[k]+dd,有max_n[nn]=max_n[k]+num[nn],而当dis[nn]==dis[k]+dd且max_n[k]+num[nn]>max_n[nn]时有max_n[nn]=max_n[k]+num[nn];
4. 最后输出路径时用递归就好

#include<bits/stdc++.h>

#define read() freopen("input.txt","r",stdin)
#define write() freopen("output.txt","w",stdout)
using namespace std;
const int maxn = 510;
int n, m, s, d, num[maxn];
int dis[maxn], done[maxn], pre[maxn];
int min_n[maxn], max_n[maxn];

struct Edge{
    int from,to,dist;
    Edge(int u,int v,int d):from(u),to(v),dist(d){};
};
struct HeapNode {
    int dist, from;
    HeapNode(int d, int f):dist(d),from(f){};
    bool operator < (const HeapNode & rhs)const{
        return dist > rhs.dist;
    }
};

void path(int d) {
    if (pre[d] != -1) {
        path(pre[d]);
        printf("%d ", pre[d]);
    }
}
vector<Edge> edges[maxn];
void dijkstra(int s) {
    priority_queue<HeapNode> queue;
    queue.push(HeapNode(0, s));
    dis[s] = 0;
    min_n[0] = 1;
    max_n[s] = num[s];
    while (!queue.empty()) {
        HeapNode top = queue.top();
        queue.pop();
        int node = top.from;
        if(done[node]) continue;
        else done[node] = true;
        for (int i = 0; i < edges[node].size(); i++) {
            Edge& e = edges[node][i];
            if (dis[e.to] > dis[node] + e.dist) {
                dis[e.to] = dis[node] + e.dist;
                min_n[e.to] = min_n[node];
                max_n[e.to] = max_n[node] + num[e.to];
                pre[e.to] = node;
                queue.push(HeapNode(dis[e.to], e.to));
            } else if (dis[e.to] == dis[node] + e.dist) {
                min_n[e.to] += min_n[node];
                if (max_n[node] + num[e.to] > max_n[e.to]) {
                    pre[e.to] = node;
                    max_n[e.to] = max_n[node] + num[e.to];
                    queue.push(HeapNode(dis[e.to], e.to));
                }
            }
        }
    }
}

int main() {
    cin >> n >> m >> s >> d;
    for (int i = 0; i <= n; i++) {
        dis[i] = maxn;
        pre[i] = -1;
    }
    for (int i = 0; i < n; i++) cin >> num[i];
    for (int i = 0; i < m; i++) {
        int v1, v2, len;
        cin >> v1 >> v2 >> len;
        edges[v1].push_back(Edge(v1, v2, len));
        edges[v2].push_back(Edge(v2, v1, len));
    }
    dijkstra(s);
    cout << min_n[d] << ' ' << max_n[d] << '\n';
    path(d);
    printf("%d\n", d);
    return 0;
}