[LeetCode] Insert Interval 二分搜索

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

 

Hide Tags

 Array Sort

 

---

　　这题是给定一组区间，然后再有一个区间，把重叠的区间合并，合并后的区间输出。

思路1：

　　简单的想法便是顺序遍历，将新的区间加入后排序，然后合并重叠的，之前写过了这个。

 

思路2：

　　思路1 合并的只会操作一次，所以换一个，因为一组区间是有序的，所以可以试图找出合并的头、尾，这样便能够加速。为了快速定位合并的头尾，可以使用二分搜索。

　　我定义了一个二分搜索，用于查找一组区间中，按头比较，找出不大于target 的最大区间头的idx。

 

　　这样便有了大概的定位，然后把一组区间中做部分的加入返回，然后创造新的区间，加入返回，最后把剩余的后部区间加入返回。

　　需要注意的是创造区间有可能并不与其他合并，即 加入的区间 不和其他区间重叠，比较麻烦的是确定切割的地方。

 

#include <vector>
#include <iostream>
using namespace std;
/**
 * 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<Interval> insert(vector<Interval> &intervals, Interval newInterval) {
        int n = intervals.size();
        if(n<1) return vector<Interval>{{newInterval.start,newInterval.end}};
        vector<Interval> ret;
//        if(n==1){
//            if(newInterval.end<intervals[0].start){
//                ret.push_back(newInterval); ret.push_back(intervals[0]);
//                return ret;
//            }
//            if(intervals[0].end<newInterval.start){
//                ret.push_back(intervals[0]);    ret.push_back(newInterval);
//                return ret;
//            }
//        }
        int idx1 =binsearch(intervals,newInterval.start);
        int idx2 =binsearch(intervals,newInterval.end);
        int idx_tmp,newStart;
        if(intervals[idx1].end>=newInterval.start){
            idx_tmp = idx1-1;
            newStart = intervals[idx1].start<newInterval.start?intervals[idx1].start:newInterval.start;
        }
        else{
            idx_tmp=idx1;
            newStart = newInterval.start;
        }
        for(int i=0;i<=idx_tmp;i++) ret.push_back(intervals[i]);
        int newEnd;
        if(newInterval.end<intervals[idx2].start){
            newEnd = newInterval.end;
            idx_tmp = idx2;
        }
        else{
            newEnd = intervals[idx2].end>newInterval.end?intervals[idx2].end:newInterval.end;
            idx_tmp = idx2+1;
        }
        ret.push_back(Interval(newStart,newEnd));
        for(int i=idx_tmp;i<n;i++)   ret.push_back(intervals[i]);
        return ret;
    }

    int binsearch(vector<Interval> &ints,int target)
    {
        if(ints.size()==1)  return 0;
        int lft = 0,rgt = ints.size()-1;
        if(ints[rgt].start<=target) return rgt;
        if(ints[lft].start>=target) return lft;
        int ret = 0;
        do{
            int mid = (lft+rgt)/2;
            if(ints[mid].start>target)  rgt=mid;
            else    lft=mid;
            ret = lft;
            if(ints[ret+1].start>target)    break;
        }while(lft+1<rgt);
        return ret;
    }
};

int main(){
    vector<Interval> intervals{{1,2},{3,5},{6,7},{8,10},{12,16}};
//    vector<Interval> intervals{{1,2}};
//    cout<<intervals[0].start<<" "<<intervals[1].end<<endl;
    Interval newInterval(-1,0);
    Solution sol;
    vector<Interval> ret = sol.insert(intervals,newInterval);
    for(int i=0;i<ret.size();i++)
        cout<<ret[i].start<<" "<<ret[i].end<<endl;
    return 0;
}