L2-001 紧急救援(Java)

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

输入格式:

输入第一行给出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. 问题类型：这是一个带权重的图的最短路径问题。图中的节点表示城市，边表示城市间的道路，边的权重表示道路的长度，而节点的权重表示每个城市的救援队数量。
2. 特殊要求：

• • 找到从一个给定的起始城市到目的城市的最短路径。
  • 在所有可能的最短路径中，选择可以累积最多救援队的路径。

1. 输入格式：

• • 城市数量N、道路数量M、起始城市编号S、目的城市编号D。
  • 接下来的一行，每个城市的救援队数量。
  • 接下来的M行，每行描述一条道路，包括两个城市的编号和道路长度。

1. 输出格式：

• • 第一行输出两个数字：最短路径的数量和沿这些路径可以召集的最多救援队数量。
  • 第二行输出任意一条这样的路径，城市编号以空格分隔。

解题方法：

1. 数据结构选择：使用邻接矩阵或邻接表来存储图。考虑到效率，对于稀疏图（节点多，边相对少），邻接表更合适。
2. 算法选择：使用Dijkstra算法来找出最短路径。由于需要计算最短路径的数量和沿途最多的救援队数量，需要在Dijkstra算法的基础上进行修改，以存储额外的信息。
3. 实现步骤：

• • 使用Dijkstra算法计算从起始城市到其他所有城市的最短路径。
  • 在执行算法的过程中，同时跟踪每个城市可达的最短路径数量和该路径上的救援队总数。
  • 在找到目的城市的最短路径后，输出最短路径数量和最大救援队数量。
  • 使用回溯法，根据前驱节点信息，输出一条满足条件的路径。

这类问题的关键在于理解图的结构和Dijkstra算法的工作原理，以及如何在此基础上添加额外的条件（如权重最大化）。理解这些概念后，你将能够分析和解决类似的图论问题。

解题过程中遇到的问题

最后一点是超时的

代码

import java.util.*;

public class Main {
    static final int MAXN = 500;
    static final int INF = Integer.MAX_VALUE;
    static int[][] graph = new int[MAXN][MAXN];
    static int[] rescueTeams = new int[MAXN]; //每个城市的救援队数量
    static int[] dist = new int[MAXN]; //存储从S到每个城市的最短距离
    static int[] num = new int[MAXN]; //存储到达每个城市的最短路径数量。
    static int[] maxRescue = new int[MAXN]; //存储从S到每个城市可以召集的最多救援队数量。
    static boolean[] visited = new boolean[MAXN];
    static int[] pre = new int[MAXN]; // 前驱节点数组。存储到达每个城市的前一个城市，用于最后回溯找到路径。

    /**
     * N 城市个数
     * M 快速道路的条数
     * S 出发地的城市编号
     * D 目的地的城市编号
     */
    static int N, M, S, D;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        N = scanner.nextInt();
        M = scanner.nextInt();
        S = scanner.nextInt();
        D = scanner.nextInt();

        for (int[] row : graph) {
            Arrays.fill(row, INF);
        }

        for (int i = 0; i < N; i++) {
            rescueTeams[i] = scanner.nextInt();
        }

        for (int i = 0; i < M; i++) {
            int u = scanner.nextInt();
            int v = scanner.nextInt();
            int length = scanner.nextInt();
            graph[u][v] = graph[v][u] = length;
        }

        // 初始化pre数组
        Arrays.fill(pre, -1);

        dijkstra(S);

        System.out.println(num[D] + " " + maxRescue[D]);

        // 输出路径
        Stack<Integer> path = new Stack<>();
        for (int v = D; v != -1; v = pre[v]) {
            path.push(v);
        }

        while (!path.isEmpty()) {
            System.out.print(path.pop());
            if (!path.isEmpty()) {
                System.out.print(" ");
            }
        }
    }

    public static void dijkstra(int s) {
        // 初始化所有节点的最短距离为无穷大
        Arrays.fill(dist, INF);
        // 初始化每个节点的最短路径数量为0
        Arrays.fill(num, 0);
        // 初始化每个节点可以召集的最多救援队数量为0
        Arrays.fill(maxRescue, 0);
        // 初始化所有节点为未访问状态
        Arrays.fill(visited, false);

        // 设置起点s到自己的最短距离为0，最短路径数量为1
        dist[s] = 0;
        num[s] = 1;
        // 救援队数量为起点的救援队数量
        maxRescue[s] = rescueTeams[s];

        // 对图中的所有节点进行遍历
        for (int i = 0; i < N; i++) {
            // u用于记录未访问节点中dist值最小的节点，minD记录这个最小的dist值
            int u = -1, minD = INF;
            // 寻找未访问的、dist值最小的节点
            for (int j = 0; j < N; j++) {
                if (!visited[j] && dist[j] < minD) {
                    u = j;
                    minD = dist[j];
                }
            }


            // 如果没有找到这样的节点，说明剩余的所有节点都不可达，跳出循环
            if (u == -1) {
                break;
            }
            // 标记节点u为已访问
            visited[u] = true;

            // 遍历所有节点，更新通过u节点到其他未访问节点的最短路径
            for (int v = 0; v < N; v++) {
                // 对于每一个未访问的邻接节点v，尝试通过u进行中转，看是否可以更新最短路径
                if (!visited[v] && graph[u][v] != INF) {
                    // 如果通过u到v的路径比当前记录的到v的最短路径还短
                    if (dist[u] + graph[u][v] < dist[v]) {
                        // 更新到v的最短距离
                        dist[v] = dist[u] + graph[u][v];
                        // 更新到v的最短路径数量为到u的最短路径数量
                        num[v] = num[u];
                        // 更新到v的最大救援队数量
                        maxRescue[v] = maxRescue[u] + rescueTeams[v];
                        // 更新v的前驱节点为u，用于最后回溯路径
                        pre[v] = u;
                    } else if (dist[u] + graph[u][v] == dist[v]) {
                        // 如果通过u到v的路径与当前记录的到v的最短路径长度相同
                        // 增加到v的最短路径数量
                        num[v] += num[u];
                        // 如果通过u到v的路径可以得到更多的救援队，或者救援队数量相同但选择更新（这里可以根据实际情况决定是否更新pre[v]）
                        if (maxRescue[u] + rescueTeams[v] > maxRescue[v]) {
                            maxRescue[v] = maxRescue[u] + rescueTeams[v];
                            pre[v] = u;
                        } else if (maxRescue[u] + rescueTeams[v] == maxRescue[v]) {
                            // 当存在多条路径且救援队数量相同时，可以选择不更新pre[v]，或者根据具体需求处理
                        }
                    }
                }
            }
        }
    }

}