|
| 1 | +### 题目描述 |
| 2 | + |
| 3 | +这是 LeetCode 上的 **[436. 寻找右区间](https://leetcode.cn/problems/find-right-interval/solution/by-ac_oier-sijp/)** ，难度为 **简单**。 |
| 4 | + |
| 5 | +Tag : 「排序」、「二分」、「双指针」、「莫队算法」 |
| 6 | + |
| 7 | + |
| 8 | + |
| 9 | +给你一个区间数组 `intervals` ，其中 $intervals[i] = [start_i, end_i]$，且每个 $start_i$ 都 不同 。 |
| 10 | + |
| 11 | +区间 $i$ 的 右侧区间 可以记作区间 $j$ ，并满足 $start_j >= end_i$ ，且 $start_j$ 最小化 。 |
| 12 | + |
| 13 | +返回一个由每个区间 $i$ 的 右侧区间 的最小起始位置组成的数组。如果某个区间 $i$ 不存在对应的 右侧区间 ，则下标 $i$ 处的值设为 $-1$ 。 |
| 14 | + |
| 15 | +示例 1： |
| 16 | +``` |
| 17 | +输入：intervals = [[1,2]] |
| 18 | +
|
| 19 | +输出：[-1] |
| 20 | +
|
| 21 | +解释：集合中只有一个区间，所以输出-1。 |
| 22 | +``` |
| 23 | +示例 2： |
| 24 | +``` |
| 25 | +输入：intervals = [[3,4],[2,3],[1,2]] |
| 26 | +
|
| 27 | +输出：[-1,0,1] |
| 28 | +
|
| 29 | +解释：对于 [3,4] ，没有满足条件的“右侧”区间。 |
| 30 | +对于 [2,3] ，区间[3,4]具有最小的“右”起点; |
| 31 | +对于 [1,2] ，区间[2,3]具有最小的“右”起点。 |
| 32 | +``` |
| 33 | +示例 3： |
| 34 | +``` |
| 35 | +输入：intervals = [[1,4],[2,3],[3,4]] |
| 36 | +
|
| 37 | +输出：[-1,2,-1] |
| 38 | +
|
| 39 | +解释：对于区间 [1,4] 和 [3,4] ，没有满足条件的“右侧”区间。 |
| 40 | +对于 [2,3] ，区间 [3,4] 有最小的“右”起点。 |
| 41 | +``` |
| 42 | + |
| 43 | +提示： |
| 44 | +* $1 <= intervals.length <= 2 \times 10^4$ |
| 45 | +* $intervals[i].length == 2$ |
| 46 | +* $-10^6 <= start_i <= end_i <= 10^6$ |
| 47 | +* 每个间隔的起点都 不相同 |
| 48 | + |
| 49 | +--- |
| 50 | + |
| 51 | +### 排序 + 二分 |
| 52 | + |
| 53 | +为了方便，我们称 $intervals$ 为 $its$。 |
| 54 | + |
| 55 | +对于每个 $its[i]$ 而言，我们需要在所有满足「$its[j][0] \geqslant its[i][1]$」中找到 $its[j][0]$ 值最小的下标 $j$，并将其记为 $ans[i]$。 |
| 56 | + |
| 57 | +对于一个特定的 $its[i]$ 而言，其右端点固定，并且我们只关心目标位置的左端点。 |
| 58 | + |
| 59 | +因此我们可以构造一个记录区间左端点的数组 $clone$，并将其进行排序，同时为了记录每个左端点来自于原序列中的那个下标，还需要额外记录原序列下标，即以 $(start, idx)$ 二元组的形式进行转存，并根据 $start$ 排序。 |
| 60 | + |
| 61 | +然后从前往后处理每个 $its[i]$，运用「二分」在 $clone$ 中找到第一个满足左端点 $start$ 大于等于 $its[i][1]$ 的成员 $clone[j]$，将其 $clone[j][1]$ 即是 $its[i]$ 的最右区间。 |
| 62 | + |
| 63 | +代码： |
| 64 | +```Java |
| 65 | +class Solution { |
| 66 | + public int[] findRightInterval(int[][] its) { |
| 67 | + int n = its.length; |
| 68 | + int[][] clone = new int[n][2]; |
| 69 | + for (int i = 0; i < n; i++) clone[i] = new int[]{its[i][0], i}; |
| 70 | + Arrays.sort(clone, (a,b)->a[0]-b[0]); |
| 71 | + int[] ans = new int[n]; |
| 72 | + for (int i = 0; i < n; i++) { |
| 73 | + int l = 0, r = n - 1; |
| 74 | + while (l < r) { |
| 75 | + int mid = l + r >> 1; |
| 76 | + if (clone[mid][0] >= its[i][1]) r = mid; |
| 77 | + else l = mid + 1; |
| 78 | + } |
| 79 | + ans[i] = clone[r][0] >= its[i][1] ? clone[r][1] : -1; |
| 80 | + } |
| 81 | + return ans; |
| 82 | + } |
| 83 | +} |
| 84 | +``` |
| 85 | +* 时间复杂度：排序复杂度为 $O(n\log{n})$；对于每个 $its[i]$ 找到最右区间需要进行二分，复杂度为 $O(n\log{n})$。整体复杂度为 $O(n\log{n})$ |
| 86 | +* 空间复杂度：$O(n)$ |
| 87 | + |
| 88 | +--- |
| 89 | + |
| 90 | +### 双指针（莫队思想） |
| 91 | + |
| 92 | +更进一步，在解法一中我们并没有对求解询问的顺序进行调整，这导致了我们不得不每次都在整个左端点序列中进行二分。 |
| 93 | + |
| 94 | +朴素处理询问的方式，需要每次对整个序列进行扫描，复杂度为 $O(n^2)$。 |
| 95 | + |
| 96 | +实际上，如果我们按照「右端点从小到大」的顺序处理询问，其每个询问对应的「最右区间的左端点」也具有单调特性。 |
| 97 | + |
| 98 | +因此，我们可以运用莫队思想：**通过调整询问的处理顺序，来减少扫描目标位置的指针移动次数。将其从「必然进行 $n^2$ 次移动」优化为「最多不超过 $n$ 次移动」，从而将 构造答案 的复杂度从 $O(n^2)$ 优化为 $O(n)$。** |
| 99 | + |
| 100 | +最后，由于每个 $its[i]$ 只关心目标位置的「左端点」，因此我们无须对某一段进行分块，而直接使用双指针实现即可。 |
| 101 | + |
| 102 | +代码： |
| 103 | +```Java |
| 104 | +class Solution { |
| 105 | + public int[] findRightInterval(int[][] its) { |
| 106 | + int n = its.length; |
| 107 | + int[][] ss = new int[n][2], es = new int[n][2]; |
| 108 | + for (int i = 0; i < n; i++) { |
| 109 | + ss[i] = new int[]{its[i][0], i}; |
| 110 | + es[i] = new int[]{its[i][1], i}; |
| 111 | + } |
| 112 | + Arrays.sort(ss, (a,b)->a[0]-b[0]); |
| 113 | + Arrays.sort(es, (a,b)->a[0]-b[0]); |
| 114 | + int[] ans = new int[n]; |
| 115 | + for (int i = 0, j = 0; i < n; i++) { |
| 116 | + int[] cur = es[i]; |
| 117 | + int loc = cur[0], idx = cur[1]; |
| 118 | + while (j < n && ss[j][0] < loc) j++; |
| 119 | + ans[idx] = j == n ? -1 : ss[j][1]; |
| 120 | + } |
| 121 | + return ans; |
| 122 | + } |
| 123 | +} |
| 124 | +``` |
| 125 | +* 时间复杂度：排序复杂度为 $O(n\log{n})$；双指针构造答案的复杂度为 $O(n)$。整体复杂度为 $O(n\log{n})$ |
| 126 | +* 空间复杂度：$O(n)$ |
| 127 | + |
| 128 | +--- |
| 129 | + |
| 130 | +### 最后 |
| 131 | + |
| 132 | +这是我们「刷穿 LeetCode」系列文章的第 `No.436` 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。 |
| 133 | + |
| 134 | +在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。 |
| 135 | + |
| 136 | +为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。 |
| 137 | + |
| 138 | +在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。 |
| 139 | + |
0 commit comments