leetcode--无重叠区间

题目

给定一个区间的集合 intervals ，其中 intervals[i] = [starti, endi] 。返回 需要移除区间的最小数量，使剩余区间互不重叠 。

示例1：

输入: intervals = [[1,2],[2,3],[3,4],[1,3]]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例2：

输入: intervals = [ [1,2], [1,2], [1,2] ]
输出: 2
解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例3：

输入: intervals = [ [1,2], [2,3] ]
输出: 0
解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

提示：

• 1 <= intervals.length <= 10^5
• intervals[i].length == 2
• -5 * 10^4 <= starti < endi <= 5 * 10^4

动态规划

我们的目的是移除最少数量的区间，使得剩余区间互不重叠。这其实就等价于，我们在给定的区间集合intervals中，寻找最多互不重叠区间的集合。

我们按每个区间的start从小到大进行排序，以便于能够快速判断两个区间是否重叠：后一个区间的start小于前一个的end，则重叠。

因为最多互不重叠区间的集合一定是以intervals中的某个区间结尾的，因此我们令dp[i]为以第i的区间结尾的，能够共存区间的最大值。这样dp[i] 的最大值就是我们想要的集合中区间的数量。

dp的更新规则在代码中很容易看出

class Solution {
public:
    int eraseOverlapIntervals(vector>& intervals) {
        int n = intervals.size();
        if(n <= 1) return 0;
        int cnt = 1;
        sort(intervals.begin(), intervals.end()); // 按 start 值由小到大排序
        vector dp(n, 1); // 动态规划状态
        for(int i = 1; i < n; i++){ // 求dp[i]
            for(int j = 0; j < i; j++){ // 通过dp[j]来求
                if(intervals[j][1] <= intervals[i][0]){
                    dp[i] = max(dp[i], dp[j] + 1); // 以第 i 个区间结尾，无重叠区间的最大数目
                    cnt = max(cnt, dp[i]);
                }
            }
        }
        return n - cnt;
    }
};

这个思路是参考了官方题解的，复杂度较高（官方解直接copy都会TLE），本人使用的是贪心算法

• 时间复杂度$O(n^2)$
• 空间复杂度$O(n)$

贪心(推荐)

同样地，为了方便判断两个区间是否重叠，我们对intervals按start从小到大进行排序。可以确定的是，若两个区间有重叠，我们至少要删除一个。

• 删除能够提供为其它区间提供更大空间的区间，使得剩下的那个不容易与其他区间重叠

因为我们按start排序了，因此重叠有以下两种情况

• 对于第二种，毫无疑问，删除外面那个大的区间，保留小的区间

• 对于第一种，因为我们是从左向右遍历的，因此 i 之前（包括i）保留的区间已经是无重叠的了，我们只需要给右边的区间提供更大的区间就行了，所以我们保留end比较小的，删除end比较大的，也就是保留i，删除后面一个

• 综上，若有重叠，我们删除end比较大的区间

class Solution {
public:
    int eraseOverlapIntervals(vector>& intervals) {
        if(intervals.size() <= 1) return 0;
        sort(intervals.begin(), intervals.end());
        vector temp = intervals[0]; // 保留区间的最后一个
        int cnt = 0;// 计算删除了多少个
        int index = 1;
        while(index <= intervals.size() - 1){
            if(temp[1] > intervals[index][0]){ // 若有重叠
                temp[1] = min(temp[1], intervals[index][1]); // 保留 end 小的，不需要更新 start
                cnt++; // 被删除区间个数加一
            }
            else temp = intervals[index]; // 若没有重叠，直接保留，并更新保留集合的最后一个区间
            index++;
        }
        return cnt;
    }
};

• 时间复杂度$O(n)$
• 空间复杂度$O(\log n)$：排序需要的栈空间（可以不使用 sort，会更小）