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].

/** * 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:#define M2    #ifdef M1// O(n2) time, O(1) space, TLE超时    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {        vector<Interval>::iterator iter = intervals.begin();        while(iter != intervals.end()) {            if (newInterval.end < iter->start) {                intervals.insert(iter, newInterval);                return intervals;            }            else if (iter->end < newInterval.start) {                ++iter;            }            else {                newInterval.start = min(newInterval.start, iter->start);                newInterval.end   = max(newInterval.end, iter->end);                iter = intervals.erase(iter); // erase will return iterator of next item before iter is removed.            }        }        intervals.insert(intervals.end(), newInterval);        return intervals;    }#endif#ifdef M2/*利用intervals已经排序的特点，采用二分查找，可以在O(lgn)时间内找到起点和终点。这里的最坏情况还是O(n)，即要insert的Interval跨头和尾的位置。binarySearch:// 二分查找的变形，将intervals中所有的元素展开（也就是说不分start，end），可以看成一个排序数组。// low，mid，high和经典二分查找类似;// mid为在展开的数组中的下标，而idx为该元素在intervals数组的下标;// mid对应的是intervals[idx]的start还是end呢？ 如果mid-2*idx == 1, 则是end，==0,则是start。// 这个函数有点类似于lower_bound， 它的返回值也可以参考lower_bound来理解。[ [1,2] ], 0: 返回0[ [1,5] ], 3: 返回0[ [3,6] ], 7: 返回1[ [1,2] [5,8] ], 0/1/2: 返回0[ [1,2] [5,8] ], 3/4/5/6/7/8: 返回1[ [1,2] [5,8] ], 9: 返回2*/    int binarySearch(vector<Interval> &intervals, int val) {        int low = 0, high = intervals.size()*2-1;        while(low <= high) {            int mid = (low+high)/2; // index in all numbers            int idx = mid/2; // index in intervals array            int midv;            Interval midItem= intervals[idx];                        //mid -2*idx == 1 or 0            midv = (mid-2*idx) ? midItem.end : midItem.start;                        if (midv == val) {                return idx;            }            else if (midv < val) {                low = mid+1;            }            else {                high = mid-1;            }        }                return low/2;    }    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {        int pos1 = binarySearch(intervals, newInterval.start);        int pos2 = binarySearch(intervals, newInterval.end);                // newInterval.start is bigger than all numbers in intervals or intervals is empty        // [], [1,2] => [ [1,2] ]        // [ [1,2] ], [3, 4] => [ [1,2] [3,4] ]        if (pos1 == intervals.size()) {            intervals.push_back(newInterval);            return intervals;        }        // if newInterval.end is bigger than all numbers in interval, then it will merge with last item.        // [ [1,3] ], [2, 5] => [ [1,5] ]        if (pos2 == intervals.size()) {            pos2 = intervals.size()-1;        }                // 对于newInterval.start，有两种情况：         // newInterval.start < intervals[pos1].start        // newInterval.start >= intervals[pos1].start        // 不管哪种情况，都需要将newInterval和intervals[pos1]合并。        newInterval.start = min(newInterval.start, intervals[pos1].start);                // 对于newInterval.end, 同样有两情况：        // newInterval.end < intervals[pos2].start        // newInterval.end >= intervals[pos2].start         // 对于第一种情况，我们需要将newInterval和intervals[pos2-1]合并。此时注意要保证pos2-1>=0        // 对于第二种情况，我们将newInterval和intervals[pos2]合并即;        if (newInterval.end < intervals[pos2].start) {            if (pos2-1 >= 0) {                newInterval.end = max(newInterval.end, intervals[pos2-1].end);            }            pos2--;        }        else {            newInterval.end = max(newInterval.end, intervals[pos2].end);        }                // [ [3,5] ], [1,2] => [ [1,2] [3,5] ], pos1=0, pos2=0-1=-1        // [ [3,5] [8,9] ], [6,7] => [ [3,5] [6,7] [8,9] ], pos1=1, pos2=1-1=0        if (pos1 > pos2) {            intervals.insert(next(intervals.begin(), pos1), newInterval);        }        else {            // [ [2,5] ], [3,4] => [ [2,5] ], pos1=0, pos2=0            // [ [1,4] [6,8] ], [2,5] => [ [1,5] [6,8] ], pos1=0, pos2=1-1=0            // [ [1,4] [6,8] ], [2,7] => [ [1,8] ], pos1=0, pos2=1            typedef vector<Interval>::iterator Iterator;            Iterator iter1 = next(intervals.begin(), pos1);            Iterator iter2 = next(intervals.begin(), pos2+1); //[first, last), 所以pos2+1,不然pos2那个位置不会被erase。                        iter1 = intervals.erase(iter1, iter2); // 返回iter2之后的位置，这里返回的iter1已经不等于iter2了，因为iter2已经失效了。            intervals.insert(iter1, newInterval);        }        return intervals;    }#endif};class Solution {public:/*如果用网上的代码，最好的情况是直接插入，不用合并，O(n)，最坏的情况是待插入的Interval横跨所有的Intervals，O(n2)，因为erase时需要拷贝数组元素，所以会超时。原来自己也写过一个用二分查找的方法，但现在觉得那个代码要判断的条件太多了。这种代码自己平时有时间是可以写出来的，但是需要一些调试才能保证正确性。于是再次思考，觉得应该有更好的写法，因此有了以下代码。这个代码思路清晰，简洁，不容易出错，给别人解释也比较容易。空间复杂度： 这种实现需要O(n)的空间。时间复杂度：构造vector<int>， O(n)binary search： O(logn);insert: 最坏是在头部插入O(n)，最好是在尾部插入，O(1)，平均是O(n);distance: O(1), 注意insert时如果用list插入效率高，但是distance就得O(n)了;构造vector<Interval> O(n)所以最坏情况也是O(n)的时间复杂度。原理：1. 先用一个int数组保存Interval中的数，由于已经排序，所以可以用binary search。   理解STL中的lower_bound很重要，经典代码不多说。2. 找到合适的插入位置之后，分别插入newInterval的start和end，得到他们插入之后的位置。3. 第一个位置应该在某个Interval的左边，第二个位置则需要在某个Interval的右边，如果不是则需要调整这两个位置。    在处理第二个位置时，对于相同元素要进一步处理：    Input:  [[1,5]], [0,1]    Output: [[0,1],[1,5]]    Expected:   [[0,5]]4. 这两个位置之间的元素都需要去掉，其它的元素保留， 所以只需将有效元素重新填到Interval数组中去即可。*/    // lower_bound 返回大于等于val的第一个位置    template <typename FI, typename T>    FI lower_bound(FI first, FI last, const T &val) {        while(first < last) {            FI mid = next(first, distance(first, last)/2);            if (*mid < val) first = next(mid);            else last = mid;        }        return first;    }    vector<Interval> insert(vector<Interval> &intervals, Interval newInterval) {        vector<int> v2;        for(auto i:intervals) {            v2.push_back(i.start);            v2.push_back(i.end);        }                auto pos1 = lower_bound(v2.begin(), v2.end(), newInterval.start);         pos1 = v2.insert(pos1, newInterval.start); //  插入后返回所插入元素的实际位置        int idx1 = distance(v2.begin(), pos1); // !!! 这里必须先算出idx1,不然在下面插入newInterval.end后pos1可能会失效。                // pos2肯定大于pos1,因为newInterval.end >= newInterval.start        auto pos2 = lower_bound(v2.begin(), v2.end(), newInterval.end);        pos2 = v2.insert(pos2, newInterval.end);        int idx2 = distance(v2.begin(), pos2);                if (idx1%2 == 1) idx1--; // 保证是一个Interval的start        if (idx2%2 == 0) idx2++; // 保证是一个Interval的end                // 进一步合并相同的元素,如[[1,5],插入[0,1]后，[0, 1][1,5] => [0,5]        if (idx2+1 < v2.size() && v2[idx2] == v2[idx2+1]) idx2+=2;                // 将有效元素填入Interval数组中。        vector<Interval> result;        for(int i=0; i<idx1; i+=2) result.push_back({v2[i], v2[i+1]});        result.push_back({v2[idx1], v2[idx2]});        for(int i=idx2+1; i<v2.size(); i+=2) result.push_back({v2[i], v2[i+1]});                return result;    }};