🎈 原创

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

题目描述

城市用一个 双向连通 图表示，图中有 n 个节点，从 1 到 n 编号（包含 1 和 n）。图中的边用一个二维整数数组 edges 表示，其中每个 edges[i] = [ui, vi] 表示一条节点 ui 和节点 vi 之间的双向连通边。每组节点对由 最多一条 边连通，顶点不存在连接到自身的边。穿过任意一条边的时间是 time 分钟。

每个节点都有一个交通信号灯，每 change 分钟改变一次，从绿色变成红色，再由红色变成绿色，循环往复。所有信号灯都 同时 改变。你可以在 任何时候 进入某个节点，但是 只能 在节点 信号灯是绿色时 才能离开。如果信号灯是 绿色 ，你 不能 在节点等待，必须离开。

第二小的值 是 严格大于 最小值的所有值中最小的值。

例如，[2, 3, 4] 中第二小的值是 3 ，而 [2, 2, 4] 中第二小的值是 4 。
给你 n、edges、time 和 change ，返回从节点 1 到节点 n 需要的 第二短时间 。

注意：

你可以 任意次 穿过任意顶点，包括 1 和 n 。
你可以假设在 启程时 ，所有信号灯刚刚变成 绿色 。

示例 1：

输入：n = 5, edges = [[1,2],[1,3],[1,4],[3,4],[4,5]], time = 3, change = 5
输出：13
解释：
上面的左图展现了给出的城市交通图。
右图中的蓝色路径是最短时间路径。
花费的时间是：

• 从节点 1 开始，总花费时间=0
• 1 -> 4：3 分钟，总花费时间=3
• 4 -> 5：3 分钟，总花费时间=6
  因此需要的最小时间是 6 分钟。

右图中的红色路径是第二短时间路径。

• 从节点 1 开始，总花费时间=0

• 1 -> 3：3 分钟，总花费时间=3

• 3 -> 4：3 分钟，总花费时间=6

• 在节点 4 等待 4 分钟，总花费时间=10

• 4 -> 5：3 分钟，总花费时间=13
  因此第二短时间是 13 分钟。

  示例 2：

输入：n = 2, edges = [[1,2]], time = 3, change = 2
输出：11
解释：
最短时间路径是 1 -> 2 ，总花费时间 = 3 分钟
最短时间路径是 1 -> 2 -> 1 -> 2 ，总花费时间 = 11 分钟

提示：

2 <= n <= 104
n - 1 <= edges.length <= min(2 * 104, n * (n - 1) / 2)
edges[i].length == 2
1 <= ui, vi <= n
ui != vi
不含重复边
每个节点都可以从其他节点直接或者间接到达
1 <= time, change <= 103

思路

来自力扣每日一题的困难题，很久没做算法了，看了题目完全没思路，看了题解还是不懂，根本就想不明白为什么能用广度优先。后来跟着敲了会算是有点头绪了，因为要找最短和严格次短，所以用广度优先是最适合的。

第二个难点就是最后时间的计算，这里有个红绿灯的概念，当到达时碰到红灯就必须要等。所以做法是先存下一定要经过的路径的总数，再一个一个模拟到达时的时间，如果这个时间恰好在红灯的区间里，就要加上一个额外的等待时间。

这里可以用画图的方式来理解：

令一个周期长度为change * 2，用当前所用时间对这个周期区域，如果结果落在了红灯时长内，那么就必须要把红灯时长剩下的部分等完。

Code

class Solution {
public:
    int secondMinimum(int n, vector<vector<int>>& edges, int time, int change) {
        vector<vector<int>> Graph(n + 1);
        for(auto &e : edges) {
            Graph[e[0]].push_back(e[1]);
            Graph[e[1]].push_back(e[0]);
        }
        
        vector<vector<int>> Path(n + 1, vector<int>(2, INT_MAX));
        Path[1][0] = 0;
        queue<pair<int, int>> Q;
        Q.push({1, 0});
        while(Path[n][1] == INT_MAX) {
            auto [cur, len] = Q.front();
            Q.pop();
            for(auto &g : Graph[cur]) {
                if(len + 1 < Path[g][0]) {
                    Path[g][0] = len + 1;
                    Q.push({g, len + 1});
                }
                else if((len + 1) > Path[g][0] && (len + 1) < Path[g][1]) {
                    Path[g][1] = len + 1;
                    Q.push({g, len + 1});
                }
            }
        }
        
        
        int ans = 0;
        for(int i = 0; i < Path[n][1]; i++) {
            if(ans % (change * 2) >= change)
                ans += change * 2 - (ans % (change * 2));
            ans += time;
        }

        return ans;

    }
};