给定一组区间,对于每一个区间 i,检查是否存在一个区间 j,它的起始点大于或等于区间 i 的终点,这可以称为 j 在 i 的“右侧”。
对于任何区间,你需要存储的满足条件的区间 j 的最小索引,这意味着区间 j 有最小的起始点可以使其成为“右侧”区间。如果区间 j 不存在,则将区间 i 存储为 -1。最后,你需要输出一个值为存储的区间值的数组。
注意:
你可以假设区间的终点总是大于它的起始点。
你可以假定这些区间都不具有相同的起始点。
示例 1:
输入: [ [1,2] ]
输出: [-1]
解释:集合中只有一个区间,所以输出-1。
示例 2:
输入: [ [3,4], [2,3], [1,2] ]
输出: [-1, 0, 1]
解释:对于[3,4],没有满足条件的“右侧”区间。
对于[2,3],区间[3,4]具有最小的“右”起点;
对于[1,2],区间[2,3]具有最小的“右”起点。
示例 3:
输入: [ [1,4], [2,3], [3,4] ]
输出: [-1, 2, -1]
解释:对于区间[1,4]和[3,4],没有满足条件的“右侧”区间。
对于[2,3],区间[3,4]有最小的“右”起点。
暴力
对于集合中的每个区间,记录下该区间的终点值last; 扫描其他所有区间,找到其起点值大于last的区间。每个区间的结果存储在res数组中
时间复杂度:O(n^2):找到每个区间的答案需要扫描整个区间集合。
空间复杂度:O(n):数组 res 具有 n 个元素
class Solution {
public int[] findRightInterval(int[][] intervals) {
if(intervals == null) return -1;
int nums = intervals.length;
if(nums == 1 || nums == 0) return -1;
int[] res = new int[nums];
for(int i = 0; i<nums; i++){
int curLast = intervals[i][1];
int min = Integer.MAX_VALUE;
int minIndex = -1;
for(int j=0; j<nums; i++){
if(i==j) continue;
if(intervals[j][0] >= curLast && intervals[j][0] < min){
minIndex = j;
}
}
res[i] = minIndex;
}
return res;
}
}
哈希+排序
使用一个哈希表 hash,存储数据的形式是键值对:Key 对应区间,而Value 对应在intervals 数组中特定区间的索引。
根据区间的起点对intervals 数组进行排序。之前已经将数组的索引存储在哈希表中,以便排序后也能获得对应的索引。
由于 intervals 数组是基于起点排序的,并且对于给定的区间,结束点总是大于起始点。因此我们只需要使用索引 j 搜索区间 i+1< j < ni+1<j<n
,这样按升序扫描时遇到第一个区间就是所需的结果。
时间复杂度:O(n^2)
- 排序使用了O(nlog(n))的时间
- i的移动区间:0~n-1
- j的移动区间:(n-1)+(n-2)+…+1 = n*(n-1)/2 = O(n^2)
空间复杂度:O(n):res和hash均存储了n个元素
import java.util.HashMap;
class Solution {
public int[] findRightInterval(int[][] intervals) {
int nums = intervals.length;
//if(nums == 1) return -1;
int[] res = new int[nums];
HashMap<int[],Integer> hash = new HashMap();
for(int i=0; i < nums; i++){
hash.put(intervals[i], i);
}
Arrays.sort(intervals, (a,b) -> a[0]-b[0]); //排序的时候,只需要对起点进行排序即可
for(int i=0; i < nums; i++){
int min = Integer.MAX_VALUE;
int minIndex = -1;
for(int j = i + 1; j < nums; j++){
if(intervals[j][0] >= intervals[i][1] && intervals[j][0] < min){
min = intervals[j][0];
minIndex = hash.get(intervals[j]);
}
}
res[hash.get(intervals[i])] = minIndex;
}
return res;
}
}
排序 + 二分查找
因为 intervals 有序,则我们不必用线性的方法来搜索所需的区间,而是可以利用二分查找
来找到我们所需的区间。
如果找到所需的区间,则从哈希表中获取对用的所有添加到res 中,反之则添加 -1。
时间复杂度:O((n.log(n))。排序花费了 O(n.log(n)) 的时间,二分查找花费了 O(log(n)) 的时间。
空间复杂度:O(n),res 和 hash 均存储了 n 个元素。
在二分查找的时候,传入的是区间的右端点,查找的是大于等于区间的右端点的第 1 个值,因此它的反面就是:小于一定不是解。根据这个“减而治之”的策略,编写二分查找算法。
注意:一种特判的情况,如果有序的最后一个元素都小于传入的区间的右端点,那么直接返回 -1。
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class Solution {
public int[] findRightInterval(int[][] intervals) {
int len = intervals.length;
if (len == 0) {
return new int[0];
}
// 对原始区间进行预处理,key:起点,value:索引
// 题目中说:你可以假定这些区间都不具有相同的起始点
Map<Integer, Integer> hashMap = new HashMap<>(len);
int[] arr = new int[len];
int[] res = new int[len];
for (int i = 0; i < len; i++) {
hashMap.put(intervals[i][0], i);
arr[i] = intervals[i][0];
}
Arrays.sort(arr);
for (int i = 0; i < len; i++) {
int index = binarySearch(arr, intervals[i][1]);
if (index == -1) {
res[i] = -1;
} else {
res[i] = hashMap.get(arr[index]);
}
}
return res;
}
/**
* 查找第 1 个大于等于 target 的元素的索引
*
* @param arr
* @param target
* @return
*/
private int binarySearch(int[] arr, int target) {
int len = arr.length;
// 特判
if (arr[len - 1] < target) {
return -1;
}
int left = 0;
int right = len - 1;
while (left < right) {
int mid = (left + right) >>> 1;
if (arr[mid] < target) {
left = mid + 1;
} else {
right = mid;
}
}
return left;
}
}
使用二分搜索树
因为需要绑定对应关系,还须要排序,查找大于等于的第 1 个元素,恰好就是“天花板函数
” ceiling 的功能,一种数据结构“红黑树”就正好同时满足了这些需求,即:
红黑树 = 哈希表 + 排序
import java.util.Arrays;
import java.util.Map;
import java.util.TreeMap;
public class Solution2 {
public int[] findRightInterval(int[][] intervals) {
int len = intervals.length;
if (len == 0) {
return new int[0];
}
TreeMap<Integer, Integer> treeMap = new TreeMap<>();
int[] res = new int[len];
for (int i = 0; i < len; i++) {
treeMap.put(intervals[i][0], i);
}
for (int i = 0; i < len; i++) {
Map.Entry<Integer, Integer> entry = treeMap.ceilingEntry(intervals[i][1]);
if (entry == null) {
res[i] = -1;
} else {
res[i] = entry.getValue();
}
}
return res;
}
}
注
- int min = Integer.MAX_VALUE;
- “你可以假定这些区间都不具有相同的起始点。”–>区间都不相同,可以做hashmap的key
import java.util.HashMap; - “你可以假设区间的终点总是大于它的起始点” --> 区间内部的有序性,可以进行排序—> 可以二分查找
- 排序后,会打乱原来的索引,但是结果要求返回!!所以使用哈希表去记录原来的索引(需要记录的是索引,value就是索引)
Arrays.sort(intervals, (a,b) -> a[0]-b[0]);
根据起点值排序
实现Comparator接口的复写compare()方法
/*注意,要想改变默认的排列顺序,不能使用基本类型(int,double, char)而要使用它们对应的类*/
Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
//定义一个自定义类MyComparator的对象
Comparator cmp = new MyComparator();
Arrays.sort(a,cmp);
for(int arr:a) {
System.out.print(arr + " ");
}
}
}
//实现Comparator接口
class MyComparator implements Comparator<Integer>{
@Override
public int compare(Integer o1, Integer o2) {
/*如果o1小于o2,我们就返回正值,如果o1大于o2我们就返回负值,
这样颠倒一下,就可以实现降序排序了,反之即可自定义升序排序了*/
return o2-o1;
}
}