LeetCode 3244.新增道路查询后的最短距离 II：贪心（跃迁合并）-9行py（O(n)）

【LetMeFly】3244.新增道路查询后的最短距离 II：贪心（跃迁合并）-9行py（O(n)）

力扣题目链接：https://leetcode.cn/problems/shortest-distance-after-road-addition-queries-ii/

给你一个整数 n 和一个二维整数数组 queries。

有 n 个城市，编号从 0 到 n - 1。初始时，每个城市 i 都有一条单向道路通往城市 i + 1（ 0 <= i < n - 1）。

queries[i] = [u_i, v_i] 表示新建一条从城市 u_i 到城市 v_i 的单向道路。每次查询后，你需要找到从城市 0 到城市 n - 1 的最短路径的长度。

所有查询中不会存在两个查询都满足 queries[i][0] < queries[j][0] < queries[i][1] < queries[j][1]。

返回一个数组 answer，对于范围 [0, queries.length - 1] 中的每个 i，answer[i] 是处理完前 i + 1 个查询后，从城市 0 到城市 n - 1 的最短路径的长度。

示例 1：

输入： n = 5, queries = [[2, 4], [0, 2], [0, 4]]

输出： [3, 2, 1]

解释：

新增一条从 2 到 4 的道路后，从 0 到 4 的最短路径长度为 3。

新增一条从 0 到 2 的道路后，从 0 到 4 的最短路径长度为 2。

新增一条从 0 到 4 的道路后，从 0 到 4 的最短路径长度为 1。

示例 2：

输入： n = 4, queries = [[0, 3], [0, 2]]

输出： [1, 1]

解释：

新增一条从 0 到 3 的道路后，从 0 到 3 的最短路径长度为 1。

新增一条从 0 到 2 的道路后，从 0 到 3 的最短路径长度仍为 1。

提示:

3 <= n <= 10⁵
1 <= queries.length <= 10⁵
queries[i].length == 2
0 <= queries[i][0] < queries[i][1] < n
1 < queries[i][1] - queries[i][0]
查询中不存在重复的道路。
不存在两个查询都满足 i != j 且 queries[i][0] < queries[j][0] < queries[i][1] < queries[j][1]。

解题方法：跃迁合并

把每一条路径视为一条跃迁通道，每个点记录“自己最多能跃迁到的点”，初始值每个点能跃迁到的点都是自己的下一个节点。

新来一条“跃迁通道”有两种可能：

被一条更长(或等长)的跃迁通道覆盖
覆盖n条跃迁通道

反正不可能和其他跃迁通道有交叉。

两种情况的判断方式是“跃迁起点”指向的“能跃迁到的点”是否大于(等于)自己的“跃迁终点”

例如新加一条[1, 3]的跃迁路径，结果发现1已经能跃迁到5了，那么就说明这是一条被其他“跃迁通道”覆盖的通道

对于第一种情况：直接continue
对于第二种情况：修改所有“最大被覆盖子跃迁通道”的起点的“能跃迁到的点”

例如原本有“跃迁通道”[1, 3]，[3, 4]，[4, 7]，新增“跃迁通道”[1, 7]，

那么就将1、3、4的“能跃迁到的点”修改为7。

跃迁次数减少 $3 - 1 = 2$ 次

时空复杂度分析

时间复杂度 $O (n + q)$ ：每次修改一个点“能跃迁到的点”，总跃迁次数就会减少一；总跃迁次数最多减少到1，说明“跃迁合并”最多 $n - 1$ 次。
空间复杂度 $O (n)$ ，返回值不计入。

AC代码

C++

/*
每个点记录“自己跃迁到的点”
初始值每个点能跃迁到的点都是自己的下一个节点

新来一条“跃迁通道”有两种可能：
    + 被一条更长(或等长)的跃迁通道覆盖
    + 覆盖n条跃迁通道
反正不可能和其他跃迁通道有交叉
两种情况的判断方式是“跃迁起点”指向的“能跃迁到的点”是否大于(等于)自己的“跃迁终点”
    + 对于第一种情况：直接continue
    + 对于第二种情况：修改所有“最大被覆盖子跃迁通道”的起点的“能跃迁到的点”
*/
// FourthTry  // 简化版  // 执行用时分布:2ms,击败98.51%;消耗内存分布:108.84MB,击败83.86%.
class Solution {
public:
    vector<int> shortestDistanceAfterQueries(int n, vector<vector<int>>& queries) {
        vector<int> transitionTo(n), ans(queries.size());
        for (int i = 0; i < n; i++) {
            transitionTo[i] = i + 1;
        }
        int transitionToEndTimes = n - 1;
        for (int i = 0; i < queries.size(); i++) {
            int from = queries[i][0], to = queries[i][1], now = from;
            while (transitionTo[now] < to) {
                transitionToEndTimes--;
                int originalTo = transitionTo[now];
                transitionTo[now] = to;
                now = originalTo;
            }
            ans[i] = transitionToEndTimes;
        }
        return ans;
    }
};

Python

from typing import List

class Solution:
    def shortestDistanceAfterQueries(self, n: int, queries: List[List[int]]) -> List[int]:
        transitionTo = [i + 1 for i in range(n)]
        ans = []
        shortestTimes = n - 1
        for from_, to in queries:
            while transitionTo[from_] < to:
                shortestTimes -= 1
                transitionTo[from_], from_ = to, transitionTo[from_]
            ans.append(shortestTimes)
        return ans

Java

class Solution {
    public int[] shortestDistanceAfterQueries(int n, int[][] queries) {
        int[] transitionTo = new int[n];
        for (int i = 0; i < n; i++) {
            transitionTo[i] = i + 1;
        }
        int[] ans = new int[queries.length];
        int minTimes = n - 1;
        for (int i = 0; i < queries.length; i++) {
            int from = queries[i][0], to =  queries[i][1];
            while (transitionTo[from] < to) {
                minTimes--;
                int originalTo = transitionTo[from];
                transitionTo[from] = to;
                from = originalTo;
            }
            ans[i] = minTimes;
        }
        return ans;
    }
}  // AC,100.00%,79.09%

Go

package main

func shortestDistanceAfterQueries(n int, queries [][]int) (ans []int) {
    transitionTo := make([]int, n)
    for i := range transitionTo {
        transitionTo[i] = i + 1
    }
    minTimes := n - 1
    for _, query := range queries {
        from, to := query[0], query[1]
        for transitionTo[from] < to {
            minTimes--
            transitionTo[from], from = to, transitionTo[from]
        }
        ans = append(ans, minTimes)
    }
    return
}  // AC,81.82%,29.41%