【贪心算法】无重叠区间

无重叠区间

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:

可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。
示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。
示例 3:

输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

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

动态规划：将区间按照起点排序

我们首先自定义一个按起点排序的函数：

//按数组第一个元素排序
sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
    return u[0] < v[0];
});

我们维持一个dp数组，它表示前 i 个区间可以维持的最多区间数，那么可以最少删除就是 intervals.size() - max(dp[i])。

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0; //没有元素删除0
        //按照区间起点对intervals排序
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] < v[0];
        });
        vector<int> dp(intervals.size()); //dp数组，代表前i位置可以留下的最多区间数
        dp[0] = 1; //只有一个区间时dp[i] = 1
        int res = 1; //只有一个区间时res = 1
        for(int i = 1;i < intervals.size();i ++){
            int Max = 0; //前i个位置维持的最长长度
            for(int j = i-1;j >= 0;j --) { //从后往前找，前面任意一个区间的终点都有超过i位置的可能
                if(intervals[j][1] <= intervals[i][0]) Max = max(dp[j],Max); //Max更新
                dp[i] = Max + 1; //i位置长度等于前i个位置维持的最长长度加上当前位置
                res = max(dp[i],res); //res更新
            }
        }
        return intervals.size()-res; //给出最佳方案
    }
};

时间极差，复杂度o(n*n)。

本题要求“找到需要移除区间的最小数量”，也就是说要更多的保留集合中的区间，对于有重叠的区间，我们应该尽可能删去跨度较大的区间。

贪心算法：按照起点排序

按照起点排序的话，对于目前遍历到的区间 i，如果

①我的起点比上一个区间的终点小，那么我们为了给后面的区间更多留下来的可能性，我就选择退出

②如果我的起点比上一个区间的终点大，那么我们俩互不影响

③我的起点比上一个区间的终点大，并且我的终点比上一个区间的终点小，那么不好意思了，你走我留下

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] < v[0];
        });
        int end = intervals[0][1]; //第一个区间终点
        int prev = 0; //上一个留下来的区间
        int count = 0; //删除区间个数
        for(int i = 1;i < intervals.size();i ++){
            if(intervals[prev][1] > intervals[i][0]){ //我和上一个区间有重叠
                if(intervals[prev][1] > intervals[i][1]) prev = i; //我的终点小于上一个的终点，我留下来-情况3
                count ++; //有重叠必淘汰一个
            }else prev = i; //无重叠继续
        }
        return count;
    }
};

时间复杂度降到了o(nlogn)，一下子好看起来了。

贪心算法：按照终点排序

如果按照终点来排序，涉及到的情况就更少了，只要有当前区间的起点大于上一个区间的起点，直接跳过，count++。

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[1] < v[1]; 
        }); //按照终点排序
        int end = intervals[0][1]; //第一个区间终点
        int count = 0; //删除区间个数
        for(int i = 1;i < intervals.size();i ++){
            if(intervals[i][0] >= end){ //无重叠
                end = intervals[i][1]; //end更新
            }else count ++; //有重叠跳过
        }
        return count;
    }
};

复杂度也是o(nlogn)