Given a set of intervals, for each of the interval i, check if there exists an interval j whose start point is bigger than or equal to the end point of the interval i, which can be called that j is on the "right" of i.
For any interval i, you need to store the minimum interval j's index, which means that the interval j has the minimum start point to build the "right" relationship for interval i. If the interval j doesn't exist, store -1 for the interval i. Finally, you need output the stored value of each interval as an array.
Note:
- You may assume the interval's end point is always bigger than its start point.
- You may assume none of these intervals have the same start point.
Example 1:
Input: [ [1,2] ] Output: [-1] Explanation: There is only one interval in the collection, so it outputs -1.
Example 2:
Input: [ [3,4], [2,3], [1,2] ] Output: [-1, 0, 1] Explanation: There is no satisfied "right" interval for [3,4]. For [2,3], the interval [3,4] has minimum-"right" start point; For [1,2], the interval [2,3] has minimum-"right" start point.
Example 3:
Input: [ [1,4], [2,3], [3,4] ] Output: [-1, 2, -1] Explanation: There is no satisfied "right" interval for [1,4] and [3,4]. For [2,3], the interval [3,4] has minimum-"right" start point.我就是用的最普通的方法,对Interal数组以start从小到大来排序。然后再挨个比较每个元素的end和之后元素的start。
public int[] findRightInterval(Interval[] intervals) {
int n=intervals.length;
if(n==1){
return new int[]{-1};
}
int[] result=new int[n];
IntervalWithIndex[] intervalWithIndexs=new IntervalWithIndex[n];
for(int i=0;i<n;i++){
IntervalWithIndex in=new IntervalWithIndex(intervals[i], i);
intervalWithIndexs[i]=in;
}
Arrays.sort(intervalWithIndexs, (a,b)->(a.interval.start-b.interval.start));
for(int i=0;i<n;i++){
int index=intervalWithIndexs[i].index;
Interval interval=intervalWithIndexs[i].interval;
boolean isFind=false;
for(int j=i+1;j<n;j++){
if(intervalWithIndexs[j].interval.start>=interval.end){
isFind=true;
result[index]=intervalWithIndexs[j].index;
break;
}
}
if(isFind==false){
result[index]=-1;
}
}
return result;
}
class IntervalWithIndex{
Interval interval;
int index;
public IntervalWithIndex(Interval interval,int index) {
this.interval=interval;
this.index=index;
}
}
大神善于运用java中的类和方法。使用TreeMap。
public int[] findRightInterval(Interval[] intervals) {
int[] result = new int[intervals.length];
java.util.NavigableMap<Integer, Integer> intervalMap = new TreeMap<>();
for (int i = 0; i < intervals.length; ++i) {
intervalMap.put(intervals[i].start, i);
}
for (int i = 0; i < intervals.length; ++i) {
Map.Entry<Integer, Integer> entry = intervalMap.ceilingEntry(intervals[i].end);
result[i] = (entry != null) ? entry.getValue() : -1;
}
return result;
}
来学习一下NavigableMap的一些方法:
ceilingEntry(key):用于获取大于或等于给定key的第一个实体,如果没有则返回null。 l。
firstEntry():用于获取Map的第一个实体,如果没有则返回null。
floorEntry(key):用于获取小于或等于给定的第一个实体key,如果没有则返回null。
higherEntry():用于获取大于给定的key的第一个实体,如果没有则返回null。
lastEntry():用于获取Map最后一个实体,如果没有则返回null。
lowerEntry(key):用于获取小于给定key的第一个实体,如果没有则返回null。
有大神说,如果不可以使用TreeMap怎么办呢?
1. 把start单独构成一个list,排序starts
2. 对于每个end,假设其为X,使用 binary search 来找到 >=X 的最左start
3. 为了知道对应的原始数组里的索引,我们需要一个map,来存储<start , index>映射。因为题目中说不会有相同的start,所以是一一映射关系。
public int[] findRightInterval(Interval[] intervals) {
Map<Integer, Integer> map = new HashMap<>();
List<Integer> starts = new ArrayList<>();
for (int i = 0; i < intervals.length; i++) {
map.put(intervals[i].start, i);
starts.add(intervals[i].start);
}
Collections.sort(starts);
int[] res = new int[intervals.length];
for (int i = 0; i < intervals.length; i++) {
int end = intervals[i].end;
int start = binarySearch(starts, end);
if (start < end) {
res[i] = -1;
} else {
res[i] = map.get(start);
}
}
return res;
}
public int binarySearch(List<Integer> list, int x) {
int left = 0, right = list.size() - 1;
while (left < right) {
int mid = left + (right - left) / 2;
if (list.get(mid) < x) {
left = mid + 1;
} else {
right = mid;
}
}
return list.get(left);
}