【拒绝算法PUA】0x02- 区间合并技巧

系列文章目录

【拒绝算法PUA】0x00-位运算
【拒绝算法PUA】0x01- 区间比较技巧
【拒绝算法PUA】0x02- 区间合并技巧

---

---

问题应用场景描述

所谓区间合并，是指线段区间的合并、线段交集等。直接看Leetcode题目来总结类似题目的技巧。

Leetcode 56.区间合并

题目

以数组intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

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

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

提示：

1 <= intervals.length <= 104
intervals[i].length == 2
0 <= starti <= endi <= 104

分析

从图中可以看出区间[1, 3]和[2, 6]有重叠，另外两个线段区间没有重叠情况；因此，需要将前两个线段区间进行合并位[1, 6]。

• 解题可以分为两个步骤：

1. 排序：将线段区间集合[start, end]按照start升序排序，目的是将线段分布到同一个横向“坐标轴”体系里；如果按照end降序也是可以的。

2. 【拒绝算法PUA】0x01- 区间比较技巧中介绍了两个线段区间如何判断是否有交集，对于区间合并场景，也是相通的；

   通过比较不同线段之间的start和end即可判断是否有交集，如果有交集，则进行区间合并。合并策略： newStart = min(x1, x3) , newEnd = max(x2, x4)。

   即： [newStart, newEnd] = [min(x1, x3), max(x2, x4)]， 依次类推。

代码

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        vector<vector<int>> res;
        // 排序：按照start升序
        sort(intervals.begin(), intervals.end(), [](auto& a, auto& b){
            return a[0] < b[0];
        });

        // 将第一个区间加入res
        res.push_back(intervals[0]);

        // 遍历所有区间，并与前一个区间的起始和终点进行比较
        for (int i = 1; i < intervals.size(); i++) {
            auto& curr = intervals[i];
            // res 中最后一个元素的引用
            auto& last = res.back();
            if (curr[0] <= last[1]) { // 后一个区间的start <= 前区间的end, 说明两区间存在交集
                last[1] = max(last[1], curr[1]); // 新区间终点取二者最大值，起点是前一个区间的起点不变
            } else {
                // 如果没有交集，则处理下一个待合并区间
                res.push_back(curr);
            }
        }
        return res;
    }
};

Leetcode 986. 区间列表的交集

题目

给定两个由一些 闭区间 组成的列表，firstList 和 secondList ，其中 firstList[i] = [starti, endi] 而 secondList[j] = [startj, endj] 。每个区间列表都是成对 不相交 的，并且 已经排序 。

返回这 两个区间列表的交集 。

形式上，闭区间 [a, b]（其中 a <= b）表示实数 x 的集合，而 a <= x <= b 。

两个闭区间的 交集 是一组实数，要么为空集，要么为闭区间。例如，[1, 3] 和[2, 4]的交集为 [2, 3] 。

示例 1：

输入：firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]
输出：[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
示例 2：

输入：firstList = [[1,3],[5,9]], secondList = []
输出：[]
示例 3：

输入：firstList = [], secondList = [[4,8],[10,12]]
输出：[]
示例 4：

输入：firstList = [[1,7]], secondList = [[3,10]]
输出：[[3,7]]
 

提示：

0 <= firstList.length, secondList.length <= 1000
firstList.length + secondList.length >= 1
0 <= starti < endi <= 109
endi < starti+1
0 <= startj < endj <= 109 
endj < startj+1

分析

根据上图可以得出两线段相交的条件为： b2 >= a1 && b1 <= a2 表示：线段二右边界 >= 线段一的左边界 && 线段二的左边界 <= 线段一的右边界。

可以观察得出结论，两线段的交集范围： [左边界的最大值， 右边界的最小值] ，即[max(a1, b1), min(a2, b2)]。

代码

通过滑动窗口的方式遍历两个序列的线段区间。

class Solution {
public:
    vector<vector<int>> intervalIntersection(vector<vector<int>>& firstList, vector<vector<int>>& secondList) {
        vector<vector<int>> res {0};
        int i = 0;
        int j = 0;
        while (i < firstList.size() && j < secondList.size())
        {
            int a1 = firstList[i][0]; // left
            int a2 = firstList[i][1]; // right
            int b1 = secondList[j][0]; // left
            int b2 = secondList[j][1]; // right

            if (b2 >= a1 && b1 <= a2) {
                res.push_back({max(a1, b1), min(a2, b2)});
            }
            // 下面两种是不重合情况
            if (b2 < a2) {
                j++; // secondList滑动到下一个区间
            } else {
                i++; // firstList滑动到下一个区间
            }
        }
        return res;
    }
};

Leetcode 1288. 删除被覆盖区间

题目

给你一个区间列表，请你删除列表中被其他区间所覆盖的区间。

只有当 c <= a 且 b <= d 时，我们才认为区间 [a,b) 被区间 [c,d) 覆盖。

在完成所有删除操作后，请你返回列表中剩余区间的数目。

 

示例：

输入：intervals = [[1,4],[3,6],[2,8]]
输出：2
解释：区间 [3,6] 被区间 [2,8] 覆盖，所以它被删除了。
 

提示：​​​​​​

1 <= intervals.length <= 1000
0 <= intervals[i][0] < intervals[i][1] <= 10^5
对于所有的 i != j：intervals[i] != intervals[j]

分析

按照惯例，按照起点升序排列，如图：

• 对于排序后的相邻两组区间数据，只可能出现以下三种情形或者说相对位置：

总结：
区间覆盖、包含为目标需要删除的区间数据
区间有交集，需要合并，此处不是指真实合并
区间无交集

代码

class Solution {
public:
    int removeCoveredIntervals(vector<vector<int>>& intervals) {
        std::sort(intervals.begin(), intervals.end(), [](vector<int> &a, vector<int> &b) {
            if (a[0] == b[0]) { // 起点相同，则按照重点降序排序
                return b[1] < a[1];
            }
            return a[0] < b[0]; // 按照起点升序排序
        });

        int res = 0;
        // interval merge
        int start = intervals[0][0];
        int end = intervals[0][1];
        for (size_t i = 1; i < intervals.size(); i++)
        {
            // 获取下一个区间数据
            vector<int> &vec = intervals[i];
            // 区间包含，覆盖场景
            if (vec[0] >= start && vec[1] <= end) {
                res++;
            }
            // 区间相交，合并区间
            if (end >= vec[0] && end <= vec[1]) {
                end = vec[1];
            }
            // 不相交
            if (end < vec[0]) {
                start = vec[0];
                end = vec[1];
            }
        }
        return intervals.size() - res;
    }
};