LeetCode—56.合并区间(Merge Intervals)——分析及代码（C++）

一、题目

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-intervals
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. 利用map依次添加

（1）思路

可以对每个区间依次处理，判断该区间与前一区间的位置关系：
1）如果无重叠，直接添加进答案集；
2）如果有重叠，与前一区间合并，并判断与新的前一区间的位置关系。
由于涉及大量插入与删除操作，选用map进行处理，时间复杂度达到O(nlogn)；
因为map对key的自动排序为从大到小，选用区间的右边界为key，左边界为value。

（2）代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        int size = intervals.size();
        if (size == 0) return {};
        map<int, int> m;//key为区间右边界，value为左边界
        for (int i = 0; i < size; i++) {
            int f = intervals[i][1], s = intervals[i][0];//f记录当前左边界，s记录当前右边界
            auto index = m.lower_bound(f);//查找大于f的第一个值
            if (index == m.end() || (index->second > f)) {//在末尾或无重叠，直接插入
                m.insert({ f, s });
                index--;
            }
            else {//与前一区间合并
                index->second = min(index->second, s);
                f = index->first;
                s = index->second;
            }
            if (index != m.begin()) {//判断是否需继续合并
                index--;
                while (index->first >= s) {
                    m[f] = min(index->second, s);
                    s = m[f];
                    int todele = index->first;
                    if (index == m.begin()) {
                        m.erase(todele);
                        break;
                    }
                    index--;
                    m.erase(todele);
                }
            }
        }
        vector<vector<int>> ans;
        auto it = m.begin();
        while (it != m.end()) {
            ans.push_back({ it->second, it->first });
            it++;
        }
        return ans;
    }
};

（3）结果

执行用时 ：16 ms, 在所有 C++ 提交中击败了 99.37% 的用户；
内存消耗 ：12.3 MB, 在所有 C++ 提交中击败了 5.08% 的用户。

2. 排序后依次处理

（1）思路

前述方法实现过程的复杂性，很大程度上来源于题目所给数组是完全无序的。
因此，可以先将题目所给数组对左区间排序，这样每次操作更简洁清晰：
1）选取一个 temp，记录待存入区间；
2）对遍历到的新区间，若与 temp 无重叠，存入 temp，用新区间替代 temp；
3）若新区间与 temp 有重叠，将其与 temp 合并；
4）因已存入的区间间互相是不重叠的，且新区间左边界有序，因此新区间不可能与已存入的区间重叠。
时间复杂度：O(nlogn) + O(n) = O(nlogn)。

（2）代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        int size = intervals.size();
        if (size <= 1) return intervals;
        vector<vector<int>> ans;
        sort(intervals.begin(), intervals.end(), cmp);//排序
        vector<int> temp = intervals[0];
        for (int i = 1; i < size; i++) {//根据上述思路遍历处理
            if (intervals[i][0] > temp[1]) {
                ans.push_back(temp);
                temp = intervals[i];
            }
            else {
                temp[1] = (temp[1] > intervals[i][1]) ? temp[1] : intervals[i][1];
            }
        }
        ans.push_back(temp);
        return ans;
    }

    static bool cmp(const vector<int>& a, const vector<int>& b) {//排序函数重写方法
        return (a[0] < b[0]);
    }
};

（3）结果

执行用时 ：20 ms, 在所有 C++ 提交中击败了 95.75% 的用户；
内存消耗 ：12.3 MB, 在所有 C++ 提交中击败了 5.08% 的用户。

三、其他

当一道题的实现过程因无序变得复杂时，可多考虑先进行排序。