435. 无重叠区间

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

注意:

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

示例 1:

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

  
  

  
  
1
2
3

示例 2:

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

  
  

  
  
1
2
3

示例 3:

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

  
  

  
  
1
2
3

解题思路

我们首先想到的是暴力破解，怎么做呢？我们只需要将所有的子数组的排列都取出来，然后判断每种排列是不是符合条件即可。但是这种想法首先就被pass，这样子做太慢了，而且判断每个子排列是不是符合条件是一个很复杂的问题。

实际上这个问题和之前做过的Leetcode 300：最长上升子序列（最详细的解法！！！） 很类似，而且上述的思想也是差不多的。所以我们可以尝试通过动态规划的方法解决这个问题。我们定义函数f(i)，表示计算[0,i]这个区间内的最大不重叠区间数，那么我们的f(i)由i之前的max(f(j)) (j < index)决定，并且对于每个j元素都要满足intervals[i][0] >= intervals[j][1]。我们就得到了下面这个方程

• f(i)=max(f(j) if intervals[i][0] >= intervals[j][1]) + 1 (j < i) 我们通过这个方程可以很快写出下面这个代码

c++ 代码

bool compare(const vector<int> &a,const vector<int> &b){
    if(a[0]!=b[0])
        return a[0]<b[0];
    return a[1]<b[1];
    
}
class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size()==0)
            return 0;
        sort(intervals.begin(),intervals.end(),compare);
        //借鉴最大公共子序列
        vector<int> memo(intervals.size(),1);
        int res=0;
        for(int i=0;i<intervals.size();i++)
        {   
            for (int j=0;j<i;j++)
                if(intervals[i][0]>=intervals[j][1])
                     memo[i]=max(memo[i],memo[j]+1);
            res=max(memo[i],res);
        }
    
             return intervals.size()-res;
    }
};

python 代码

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0

        intervals.sort(key=lambda x:x[0])
        len_inter = len(intervals)
        mem = [1]*len_inter
        result = 1

        for i in range(1, len_inter):
            for j in range(0, i):
                if intervals[i][0] >= intervals[j][1]:
                    mem[i] = max(mem[i], 1 + mem[j])

            result = max(result, mem[i])

        return len_inter - result

实际上这个问题，我们可以通过贪心算法来解决。我们首先将输入的intervals按照end排序，然后保证我们每次放入区间的end最小，也就是对于后面要加入的区间留有更多的余地。

c++代码

bool compare(const vector<int> &a,const vector<int> &b){
    if(a[1]!=b[1])
        return a[1]<b[1];
    return a[0]<b[0];
    
}
class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if (intervals.size()==0)
            return 0;
        sort(intervals.begin(),intervals.end(),compare);
        //借鉴最大公共子序列

        int res=1;
        int pre=0;
        for(int i=1;i<intervals.size();i++)
        {   if(intervals[i][0]>=intervals[pre][1])
                {res ++;
                pre=i;
                }
        }
    
             return intervals.size()-res;
    }
};

python 代码

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0

        intervals.sort(key=lambda x:x[1])
        len_inter = len(intervals)
        result, pre = 1, 0
        for i in range(1, len_inter):
            if intervals[i][0] >= intervals[pre][1]:
                result += 1
                pre = i

        return len_inter - result