436. 寻找右区间 :「排序 + 二分」&「双指针（莫队思想）」题目描述这是 LeetCode 上的 436. 寻找

题目描述

这是 LeetCode 上的 436. 寻找右区间 ，难度为中等。

Tag : 「排序」、「二分」、「双指针」、「莫队算法」

给你一个区间数组 intervals ，其中 $intervals[i] = [start_i, end_i]$ ，且每个 $start_i$ 都不同。

区间 $i$ 的右侧区间可以记作区间 $j$ ，并满足 $start_j >= end_i$ ，且 $start_j$ 最小化。

返回一个由每个区间 $i$ 的右侧区间的最小起始位置组成的数组。如果某个区间 $i$ 不存在对应的右侧区间，则下标 $i$ 处的值设为 $-1$ 。

示例 1：

输入：intervals = [[1,2]]

输出：[-1]

解释：集合中只有一个区间，所以输出-1。

示例 2：

输入：intervals = [[3,4],[2,3],[1,2]]

输出：[-1,0,1]

解释：对于 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间[3,4]具有最小的“右”起点;
对于 [1,2] ，区间[2,3]具有最小的“右”起点。

示例 3：

输入：intervals = [[1,4],[2,3],[3,4]]

输出：[-1,2,-1]

解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。
对于 [2,3] ，区间 [3,4] 有最小的“右”起点。

提示：

$1 <= intervals.length <= 2 \times 10^4$
$intervals[i].length == 2$
$-10^6 <= start_i <= end_i <= 10^6$
每个间隔的起点都不相同

排序 + 二分

为了方便，我们称 $intervals$ 为 $its$ 。

对于每个 $its[i]$ 而言，我们需要在所有满足「 $its[j][0] \geqslant its[i][1]$ 」中找到 $its[j][0]$ 值最小的下标 $j$ ，并将其记为 $ans[i]$ 。

对于一个特定的 $its[i]$ 而言，其右端点固定，并且我们只关心目标位置的左端点。

因此我们可以构造一个记录区间左端点的数组 $clone$ ，并将其进行排序，同时为了记录每个左端点来自于原序列中的那个下标，还需要额外记录原序列下标，即以 $(start, idx)$ 二元组的形式进行转存，并根据 $start$ 排序。

然后从前往后处理每个 $its[i]$ ，运用「二分」在 $clone$ 中找到第一个满足左端点 $start$ 大于等于 $its[i][1]$ 的成员 $clone[j]$ ，将其 $clone[j][1]$ 即是 $its[i]$ 的最右区间。

代码：

class Solution {
    public int[] findRightInterval(int[][] its) {
        int n = its.length;
        int[][] clone = new int[n][2];
        for (int i = 0; i < n; i++) clone[i] = new int[]{its[i][0], i};
        Arrays.sort(clone, (a,b)->a[0]-b[0]);
        int[] ans = new int[n];
        for (int i = 0; i < n; i++) {
            int l = 0, r = n - 1;
            while (l < r) {
                int mid = l + r >> 1;
                if (clone[mid][0] >= its[i][1]) r = mid;
                else l = mid + 1;
            }
            ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1;
        }
        return ans;
    }
}

时间复杂度：排序复杂度为 $O(n\log{n})$ ；对于每个 $its[i]$ 找到最右区间需要进行二分，复杂度为 $O(n\log{n})$ 。整体复杂度为 $O(n\log{n})$
空间复杂度： $O(n)$

双指针（莫队思想）

更进一步，在解法一中我们并没有对求解询问的顺序进行调整，这导致了我们不得不每次都在整个左端点序列中进行二分。

朴素处理询问的方式，需要每次对整个序列进行扫描，复杂度为 $O(n^2)$ 。

实际上，如果我们按照「右端点从小到大」的顺序处理询问，其每个询问对应的「最右区间的左端点」也具有单调特性。

因此，我们可以运用莫队思想：通过调整询问的处理顺序，来减少扫描目标位置的指针移动次数。将其从「必然进行 $n^2$ 次移动」优化为「最多不超过 $n$ 次移动」，从而将构造答案的复杂度从 $O(n^2)$ 优化为 $O(n)$ 。

最后，由于每个 $its[i]$ 只关心目标位置的「左端点」，因此我们无须对某一段进行分块，而直接使用双指针实现即可。

代码：

class Solution {
    public int[] findRightInterval(int[][] its) {
        int n = its.length;
        int[][] ss = new int[n][2], es = new int[n][2];
        for (int i = 0; i < n; i++) {
            ss[i] = new int[]{its[i][0], i};
            es[i] = new int[]{its[i][1], i};
        }
        Arrays.sort(ss, (a,b)->a[0]-b[0]);
        Arrays.sort(es, (a,b)->a[0]-b[0]);
        int[] ans = new int[n];
        for (int i = 0, j = 0; i < n; i++) {
            int[] cur = es[i];
            int loc = cur[0], idx = cur[1];
            while (j < n && ss[j][0] < loc) j++;
            ans[idx] = j == n ? -1 : ss[j][1];
        }
        return ans;
    }
}

时间复杂度：排序复杂度为 $O(n\log{n})$ ；双指针构造答案的复杂度为 $O(n)$ 。整体复杂度为 $O(n\log{n})$
空间复杂度： $O(n)$

最后

这是我们「刷穿 LeetCode」系列文章的第 No.436 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：github.com/SharingSour… 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。