【PTA数据结构 | C语言版】城市间紧急救援

本专栏持续输出数据结构题目集，欢迎订阅。

题目

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

输入格式:
输入第一行给出 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

代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CITIES 500
#define INF 0x3f3f3f3f

int main() {
    int n, m, s, d;
    scanf("%d %d %d %d", &n, &m, &s, &d);
    
    // 各城市的救援队数量
    int rescue[MAX_CITIES];
    for (int i = 0; i < n; i++) {
        scanf("%d", &rescue[i]);
    }
    
    // 邻接矩阵存储道路长度
    int dist[MAX_CITIES][MAX_CITIES];
    memset(dist, 0x3f, sizeof(dist));
    for (int i = 0; i < n; i++) {
        dist[i][i] = 0;
    }
    
    // 读取道路信息
    for (int i = 0; i < m; i++) {
        int u, v, length;
        scanf("%d %d %d", &u, &v, &length);
        dist[u][v] = length;
        dist[v][u] = length;  // 道路是双向的
    }
    
    // Dijkstra算法所需数组
    int min_dist[MAX_CITIES];  // 到各城市的最短距离
    int max_rescue[MAX_CITIES];// 最短路径下的最多救援队数量
    int path_count[MAX_CITIES];// 到各城市的最短路径条数
    int prev[MAX_CITIES];      // 路径前驱节点
    int visited[MAX_CITIES];   // 标记是否已访问
    
    // 初始化
    for (int i = 0; i < n; i++) {
        min_dist[i] = INF;
        max_rescue[i] = 0;
        path_count[i] = 0;
        prev[i] = -1;
        visited[i] = 0;
    }
    min_dist[s] = 0;
    max_rescue[s] = rescue[s];
    path_count[s] = 1;
    
    // Dijkstra算法主循环
    for (int i = 0; i < n; i++) {
        // 找到当前未访问的距离最短的城市
        int u = -1;
        int min_d = INF;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && min_dist[j] < min_d) {
                min_d = min_dist[j];
                u = j;
            }
        }
        
        if (u == -1) break;  // 所有可达城市都已处理
        visited[u] = 1;      // 标记为已访问
        
        if (u == d) break;   // 到达目的地，提前退出
        
        // 更新与u相邻的城市的信息
        for (int v = 0; v < n; v++) {
            if (!visited[v] && dist[u][v] < INF) {
                int new_dist = min_dist[u] + dist[u][v];
                int new_rescue = max_rescue[u] + rescue[v];
                
                // 发现更短的路径
                if (new_dist < min_dist[v]) {
                    min_dist[v] = new_dist;
                    max_rescue[v] = new_rescue;
                    path_count[v] = path_count[u];
                    prev[v] = u;
                }
                // 发现相同长度的路径
                else if (new_dist == min_dist[v]) {
                    path_count[v] += path_count[u];
                    // 如果该路径能获得更多救援队
                    if (new_rescue > max_rescue[v]) {
                        max_rescue[v] = new_rescue;
                        prev[v] = u;
                    }
                }
            }
        }
    }
    
    // 回溯获取路径
    int path[MAX_CITIES];
    int path_len = 0;
    int current = d;
    while (current != -1) {
        path[path_len++] = current;
        current = prev[current];
    }
    
    // 输出结果
    printf("%d %d\n", path_count[d], max_rescue[d]);
    for (int i = path_len - 1; i >= 0; i--) {
        printf("%d", path[i]);
        if (i > 0) printf(" ");
    }
    
    return 0;
}