436. Find Right Interval

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:

1. You may assume the interval's end point is always bigger than its start point.
2. 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.

把区间按照起点为第一关键字，在数组中的index为第二关键字排序。

排序以后寻找当前区间I的所求的“最小右区间”，“最小右区间”是沿着当前区间I在排序后数组的位置开始向右的第一个区间X，满足X.start>=I.end，

找到区间X之后X在未排序数组中的index即为所求

需要使用原index和新index，因此用一个新的类IntervalUnit将区间和原index封装一下

查找的时候如果按顺序往后查找，最坏情况是O(N)，这样总时间复杂度为O(N^2)，因为排序过，所以可以使用二分查找来把复杂度降低为O(NlogN)

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public int[] findRightInterval(Interval[] intervals)
	{
		int len=intervals.length;
		if(len<1)
			return new int[]{};
		ArrayList<IntervalUnit> arraylist=new ArrayList<>(len);
		for(int i=0;i<len;i++)
			arraylist.add(new IntervalUnit(intervals[i], i));
		
		Collections.sort(arraylist);
		
		int[] retarr=new int[len];
		
		for(int i=0;i<len;i++)
		{
			int lo=i+1;
			int hi=len-1;
			int mid=-1;
			while(lo<=hi)
			{
				mid=lo+((hi-lo)>>1);
				int cmp=arraylist.get(mid).interval.start-arraylist.get(i).interval.end;
				if(cmp==0)
					break;
				else if(cmp<0)
					lo=mid+1;
				else {
					hi=mid-1;
				}
			}
			retarr[arraylist.get(i).index]=lo<=hi?arraylist.get(mid).index:-1;
		}
		
		return retarr;
	}
}


class IntervalUnit implements Comparable<IntervalUnit>
{
	Interval interval;
	int index;
	public IntervalUnit(Interval interval,int index)
	{
		this.interval=interval;
		this.index=index;
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public int compareTo(IntervalUnit o)
	{
		// TODO Auto-generated method stub
		if(interval.start!=o.interval.start)
			return interval.start-o.interval.start;
		return index-o.index;
	}
}