zoukankan      html  css  js  c++  java
  • 436. Find Right Interval

    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: Binary search

    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;
            }
        }
    };
  • 相关阅读:
    idea主题更换pycharm/intellij
    随机生成n张扑克牌。
    JAVA生成6个1-8的随机数,要求无重复。
    一道简单 的循环
    linux虚拟机互访
    linux中grep命令
    vi和vim编辑器
    文件压缩打包以及备份
    文件内容查询
    目录相关操作
  • 原文地址:https://www.cnblogs.com/wdw828/p/6866640.html
Copyright © 2011-2022 走看看