力扣 2045. 到达目的地的第二短时间

最新推荐文章于 2025-11-24 01:23:29 发布

原创最新推荐文章于 2025-11-24 01:23:29 发布 · 431 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #深度优先

BFS 专栏收录该内容

13 篇文章

订阅专栏

本文介绍了一道LeetCode上的题目，要求求解从起点到终点的次短时间。通过对给定边信息构建图，并利用BFS算法，实现对每个节点最短路径和次短路径的记录。最后详细解释了如何根据次短路径计算次短时间。

题目来源：https://leetcode-cn.com/problems/second-minimum-time-to-reach-destination/

大致题意：
给定一个整数 n （从 1 开始编号）表示节点数，一个 edges 数组表示相连的边，一个 time 表示每次移动需要花费的时间，一个 change 表示节点状态的持续时间（节点有两种状态：通行和停止，移动到通行状态的节点必须继续移动，移动到停止状态的节点不能移动，两种状态交替变化，初始时是通行状态）

求出从节点 1 到节点 n 需要花的次短时间（严格大于最短时间）

思路

求权重相同的最短路径问题可以用 BFS

与常规 BFS 不同，该题是求次短路径，而且也允许同一个节点多次访问，那么在 BFS 过程中，加入队列节点的判断方法应该有所改变：

使用一个二维数组存下到达每个节点最短路径和次短路径，初始时都为 int 的最大值
每次从队列取出节点后，在能到达的节点中寻找从当前位置走过去的距离比已有的距离更短的节点，可以使最短也可以是次短，如果有就放入队列

找到次短路径后，就可以通过给定的 time 和 change 计算出次短时间（因为所有节点状态同时变化，所以次短路径一定对应次短时间）

次短时间的计算方法：

判断走到当前节点时，是否是停止状态。令当前时间是 t，那么可以通过 t % (change * 2) >= change来判断
若是通行状态，直接加上 time
若是停止状态，加上需要等待的时间 change * 2 - t % (change * 2)

BFS

将给定的边的信息处理成图
初始化节点对应的路径数组
BFS 找出次短路径
计算次短时间

public int secondMinimum(int n, int[][] edges, int time, int change) {
        // 1. 将给定的边的信息处理成图
        List<Integer>[] graph = new List[n + 1];
        for (int i = 0; i <= n; i++) {
            graph[i] = new ArrayList<>();
        }
        int m = edges.length;
        for (int i = 0; i < m; i++) {
            graph[edges[i][0]].add(edges[i][1]);
            graph[edges[i][1]].add(edges[i][0]);
        }
        Queue<int[]> queue = new ArrayDeque<>();
        queue.offer(new int[]{1, 0});
        // 2. 初始化节点对应的路径数组
        int[][] len = new int[n + 1][2];
        for (int i = 0; i <= n; i++) {
            len[i][0] = Integer.MAX_VALUE;
            len[i][1] = Integer.MAX_VALUE;
        }
        len[1][0] = 0;
        // 3. BFS 找出次短路径
        while (len[n][1] == Integer.MAX_VALUE) {
            int[] arr = queue.poll();
            int node = arr[0];
            int step = arr[1] + 1;
            // 遍历当前点可以到达的点
            for (int i = 0; i < graph[node].size(); i++) {
                int next = graph[node].get(i);
                // 如果从当前点去该点的距离小于已有的最短路径，更新
                if (len[next][0] > step) {
                    queue.offer(new int[]{next, step});
                    len[next][0] = step;
                } else if (step > len[next][0] && step < len[next][1]) {
                    // 如果从当前点去该点的距离小于已有的次短路径，更新
                    queue.offer(new int[]{next, step});
                    len[next][1] = step;
                }
            }
        }

        // 4. 计算次短时间
        int ans = 0;
        for (int i = 0; i < len[n][1]; i++) {
            // 判断是否需要等待
            boolean turn = ans % (2 * change) >= change;
            if (turn) {
                // 加上等待时间
                ans += 2 * change - ans % (2 * change);
            }
            // 加上本次移动耗时
            ans += time;
        }
        return ans;
    }