LintCode 156: Merge Intervals

156 · Merge Intervals
Algorithms
Easy
Accepted Rate
32%

Description
Solution68
Notes
Discuss99+
Leaderboard
Record

Description
We take a list intervals of type Interval to represent a collection of intervals, where a single interval is (start, end). You need to merge all overlapping intervals and return an array of non-overlapping intervals that covers exactly all intervals in the input.

You need to merge intervals that have overlapping parts
You need to output an interval even if it does not overlap with any other interval

Example
Example 1:

Input: [(1,3)]
Output: [(1,3)]
Example 2:

Input: [(1,3),(2,6),(8,10),(15,18)]
Output: [(1,6),(8,10),(15,18)]
Challenge
O(n log n) time and O(1) extra space.
代码如下：

/**
 * Definition of In
 * terval:
 * classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this->start = start;
 *         this->end = end;
 *     }
 * }
 */


bool compare(Interval &a, Interval &b) {
    if (a.start == b.start) {
        return a.end < b.end;
    } else {
        return a.start < b.start;
    }
}

class Solution {
public:


    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    vector<Interval> merge(vector<Interval> &intervals) {
        
        vector<Interval> result;
        int len = intervals.size();
        if (len == 0) return result;
        if (len == 1) {
            result.push_back(intervals[0]);
            return result;
        }
        
        Interval itv;
        sort(intervals.begin(), intervals.end(), compare);
        itv = intervals[0];
        for (int i = 0; i < len - 1; ++i) {
            
            if (overlapping(itv, intervals[i + 1])) {
                itv.end = max(itv.end, intervals[i + 1].end);
                continue;
            }
            result.push_back(itv);
            itv = intervals[i + 1];
        }
        
        result.push_back(itv);
        return result;
    }
    
private:
    bool overlapping(Interval &a, Interval &b) {
        
        return ((a.end >= b.start) && (a.end <= b.end)) ||
               ((b.end >= a.start) && (b.end <= a.end));    
    }
    
};

二刷：

/**
 * Definition of Interval:
 * class Interval {
 * public:
 *     int start, end;
 *     Interval(int start, int end) {
 *         this->start = start;
 *         this->end = end;
 *     }
 * }
 */

bool operator < (const Interval &a, const Interval &b) {
    if (a.start < b.start) return true;
    if (a.start == b.start) return a.end < b.end;
    return false;
}

class Solution {
public:
    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    vector<Interval> merge(vector<Interval> &intervals) {
        int n = intervals.size();
        if (n <= 1) return intervals;
        vector<Interval> res;
        sort(intervals.begin(), intervals.end());
        for (int i = 0; i < n; i++) {
            if (res.empty() || intervals[i].start > res.back().end) {
                 res.push_back(intervals[i]);
            } else {
                res[res.size() - 1].end = max(res[res.size() - 1].end, intervals[i].end);
            }
        }
        return res;
    }
};

解法2：

/**
 * Definition of Interval:
 * class Interval {
 * public:
 *     int start, end;
 *     Interval(int start, int end) {
 *         this->start = start;
 *         this->end = end;
 *     }
 * }
 */


class Solution {
public:
    /**
     * @param intervals: interval list.
     * @return: A new interval list.
     */
    vector<Interval> merge(vector<Interval> &intervals) {
        int n = intervals.size();
        if (n <= 1) return intervals;
        sort(intervals.begin(), intervals.end(), [](const Interval &a, const Interval &b){return a.start < b.start;});
        Interval itv = intervals[0];
        vector<Interval> res;
        for (int i = 1; i < n; i++) {
            //case 1: interval[i] is covered by itv
            if (itv.start <= intervals[i].start && itv.end >= intervals[i].end) {
                //do nothing
            }
            //case 2: interval[i] is overlapped with itv
            else if (itv.start <= intervals[i].end && itv.end >= intervals[i].start) {
                itv.start = min(itv.start, intervals[i].start);
                itv.end = max(itv.end, intervals[i].end);
            }
            //case 3: no cover or overlap
            else
            {
                res.push_back(itv);
                itv = intervals[i];
            }
        }
        res.push_back(itv);
        return res;
    }
};