436. Find Right Interval

Posted 2020-09-18 蓝色地中海

Problem statement:

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.

Solution:

This is a binary search question, have not solved this problem for a long time. Brute force is a solution. Time complexity is O(n * n). Obviously, it can not pass OJ. 

My idea is as follows:

(1) Put all start values into an array, and put the start point into a hash table to get the index after we find the rightmost value

(2) Sort the start point in ascending order.

(3) Binary search to find the right index of the start array. return -1 if can not find the rightmost interval.

• Compare with easy binary search, the qualification return condition of this search is an interval. 
• We need to compare two values: mid and mid + 1. Since mid = (left + right) / 2, mid + 1 will not exceed the limitation of array.
• There are four test branches in binary check.
• Three situations for the return value.

(4) Return the value

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    vector<int> findRightInterval(vector<Interval>& intervals) {
        int size = intervals.size();
        unordered_map<int, int> table;
        vector<int> start_arr;
        for(int i = 0; i < size; i++){
            start_arr.push_back(intervals[i].start);
            table[intervals[i].start] = i;
        }
        sort(start_arr.begin(), start_arr.end());
        vector<int> right_idx(size, -1);
        for(int i = 0; i < size; i++){
            int idx = find_idx(start_arr, intervals[i].end);
            if(idx != -1){
                right_idx[i] = table[start_arr[idx]];
            }
        }
        return right_idx;
    }
    
private:
    int find_idx(vector<int>& start_arr, int val){
        int left = 0; 
        int right = start_arr.size() - 1;
        while(left + 1 < right){
            int mid = left + (right - left) / 2;
            if(start_arr[mid] == val){
                return mid;
            }if(start_arr[mid] < val && start_arr[mid + 1] >= val){
                // most right solution
                return mid + 1;
            } else if (start_arr[mid] > val){
                right = mid;
            } else if(start_arr[mid + 1] < val){
                left = mid;
            }
        }
        // three situations when binary search ends
        if(start_arr[left] >= val){
            return left;
        } else if(start_arr[right] < val){
            return -1;
        } else {
            return right;
        }
    }
};