LintCode 156: Merge Intervals

原创已于 2023-12-16 17:22:24 修改 · 218 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#LintCode

于 2018-11-12 13:39:49 首次发布

algorithm-design 专栏收录该内容

817 篇文章

订阅专栏

本文深入探讨了区间合并算法，一种高效解决区间重叠问题的方法。通过详细解释算法思路，提供了两种实现方式，包括如何判断区间重叠、合并重叠区间等关键步骤。适合对算法优化和数据结构有兴趣的读者。

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;
    }
};