LeetCode

Merge Intervals

2014.2.26 21:28

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Solution:

　　The problem didn't guarantee that the set of intervals is sorted, so a sort() has to be performed first.

　　After sorting the set, the intervals are arranged first in the order of their x-coordinates, and y-coordinates later.

　　When scanning the intervals, there will be three possibilities:

　　　　1. the next interval is contained by the current one, ignore the next one and move on

　　　　2. the next interval overlaps with the current one, merge them and move on

　　　　3. the next interval is separated from the current one, move the "current" iterator to the next one

　　Total time complexity is O(n * log(n)). Space complexity is O(1).

Accepted code:

// 1CE, 1RE, 1AC, O(n) solution.
#include <cstdlib>
#include <algorithm>
#include <vector>
using namespace std;
/*
struct Interval {
    int start;
    int end;
    Interval() : start(0), end(0) {}
    Interval(int s, int e) : start(s), end(e) {}
};
*/
bool comparator(const Interval &a, const Interval &b)
{
    if (a.start == b.start) {
        return a.end < b.end;
    } else {
        return a.start < b.start;
    }
}
 
class Solution {
public:
    vector<Interval> merge(vector<Interval> &intervals) {
        int i;
        int n = (int)intervals.size();
        int tmp;
        
        for (i = 0; i < n; ++i) {
            if (intervals[i].start > intervals[i].end) {
                tmp = intervals[i].start;
                intervals[i].start = intervals[i].end;
                intervals[i].end = tmp;
            }
        }
        
        for (i = 1; i < n; ++i) {
            if (!comparator(intervals[i - 1], intervals[i])) {
                // the array is not sorted;
                break;
            }
        }
        if (i < n) {
            sort(intervals.begin(), intervals.end(), comparator);
        }
        
        vector<Interval> result;
        int next_i;
        i = 0;
        while (i < n) {
            next_i = i + 1;
            while (next_i < n) {
                if (intervals[next_i].end <= intervals[i].end) {
                    // the next interval is included, thus skipped
                    ++next_i;
                } else if (intervals[next_i].start <= intervals[i].end) {
                    // the next interval is overlapped, thus merged
                    intervals[i].end = intervals[next_i].end;
                    ++next_i;
                } else {
                    // the next interval is non-overlapping, jump to next
                    break;
                }
            }
            result.push_back(intervals[i]);
            i = next_i;
        }
        
        return result;
    }
};