57. Insert Interval

Problem statement: 

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

Solution One:

Find the position for start and end position according to the value, obviously, this is a very complexity solution, we have to consider many situations, but we do not use extra spaces.

/**
 * 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) {
        bool b_start = false;
        bool b_end = false;
        
        vector<vector<int>::size_type> merge_interval_idx;
        Interval merge_interval;
        
        for(vector<int>::size_type ix = 0; ix < intervals.size(); ix++){
            // find where is the position of start
            if(!b_start){
                if(newInterval.start < intervals[ix].start){
                    if(newInterval.end < intervals[ix].start){
                        b_start = true;
                        b_end = true;
                        intervals.insert(intervals.begin() + ix, newInterval);
                        return intervals;
                    } else {
                        // newInterval.end >= intervals[ix].start
                        merge_interval.start = newInterval.start;
                        newInterval.end = intervals[ix].end > newInterval.end ? intervals[ix].end : newInterval.end;
                        b_start = true;
                        merge_interval_idx.push_back(ix);
                    }
                } else {
                    // newInterval.start >= intervals[ix].start
                    if(newInterval.start > intervals[ix].end){
                        continue;
                    } else {
                        // find the position of start
                        merge_interval.start = intervals[ix].start;
                        newInterval.end = intervals[ix].end > newInterval.end ? intervals[ix].end : newInterval.end;
                        merge_interval_idx.push_back(ix);
                        b_start = true;
                    }
                }
            } else if(!b_end){
                // find where is the position of end
                if(newInterval.end >= intervals[ix].start){
                    if(newInterval.end <= intervals[ix].end){
                        merge_interval.end = intervals[ix].end;
                        merge_interval_idx.push_back(ix);
                        b_end = true;
                    } else{
                        // newInterval.end > intervals[ix].end
                        merge_interval_idx.push_back(ix);
                        continue;
                    }
                } else {
                    // newInterval.end < intervals[ix].start
                    merge_interval.end = newInterval.end;
                    b_end = true; 
                    break;
                }
            }
        }
        
        // both start and end have not find their position
        // push them back to the end of intervals
        if(!b_start && !b_end){
            intervals.push_back(newInterval);
            return intervals;
        }
        
        // start has found, however end has not found
        // normally this situation happens: newInterval.end is greater than the end of last element
        if(b_start && !b_end){
           merge_interval.end = newInterval.end; 
        }
        
        // delete already merged intervals
        if(!merge_interval_idx.empty()){
            cout<<"The merge interval is: "<<merge_interval_idx[0]<<endl;
            intervals[merge_interval_idx[0]].start = merge_interval.start;
            intervals[merge_interval_idx[0]].end = merge_interval.end;
            
            for(vector<int>::size_type ix = 1; ix < merge_interval_idx.size(); ix++){
                merge_interval_idx[ix] -= ix - 1;
                cout<<"The interval index is: "<<merge_interval_idx[ix]<<endl;
            }
        
            for(vector<int>::size_type ix = 1; ix < merge_interval_idx.size(); ix++){
                intervals.erase(intervals.begin() + merge_interval_idx[ix]);
            }    
        }
        return intervals;
    }
};

Solution two: 

This solution is very simple and easy to understand, the detailed analysis is shown in the following figure, the drawback of this solution is the space complexity is O(n).

we loop to enumerate all intervals in given array, each time, there are three situations for interval[ix] and newIntervals, 

in case 1:

• insert New into merged_list, and update newInterval to be current, and continue to put left intervals into merged_list

in case 2:

• we should update the start and end position of newInterval with interval[ix], start = min(newInterval.start, interval[ix].start), end = max(newInterval.end, interval[ix].end);
• continue to next element in intervals
• push newInterval into the back of merged_list after the loop

In case 3:

• insert the interval[ix] into merged_list and continue;

class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval> merged_interval;
        for(vector<Interval>::size_type ix = 0; ix < intervals.size(); ix++){
            if(newInterval.end < intervals[ix].start){
                merged_interval.push_back(newInterval);
                newInterval = intervals[ix];
            } else if(newInterval.start > intervals[ix].end){
                merged_interval.push_back(intervals[ix]);
            } else if(newInterval.end >= intervals[ix].start || newInterval.start <= intervals[ix].end){
                newInterval.start = min(intervals[ix].start, newInterval.start);
                newInterval.end = max(intervals[ix].end, newInterval.end);
            }
        }
        
        merged_interval.push_back(newInterval);
        return merged_interval;
    }
};