【Leetcode067】无重叠区间

435、无重叠区间

给定一个区间的集合 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.1 思路分析

类似于会议时间安排问题，将区间按照右端点升序排序，然后比较前一区间右端点与后一区间的左端点是否有不重叠（可以相等）,如果是就将区间数+1，最后用总区间数-区间数。

为什么按照右端点进行排序？
右端点可以看成是会议结束的时间，结束的时间越早，越可以安排其它会议。另外我们可以明确的知道结束时间，如果按照左端点进行排序，我们只知道开始时间，但无法确定结束时间，开始时间早并不代表结束时间也早。

1.2 代码实现

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        int n = intervals.length;
        if(n == 0) return 0;
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] intervals1, int[] intervals2){
                return intervals1[1] - intervals2[1];
            }
        });
        
        int ans = 1;
        int right = intervals[0][1];
        for(int i=1; i<n; ++i){
            if(intervals[i][0] >= right){
                ans++;
                right = intervals[i][1];
            }
        }
        return n-ans;
    }
}

1.3 测试结果

1.4 复杂度

• 时间复杂度：O(nlogn)。主要是排序时间
• 空间复杂度：O(logn)。排序所需栈空间

方法二：动态规划

2.1 思路分析

2.2 代码实现

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        int n = intervals.length;
        if(n == 0) return 0;
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] intervals1, int[] intervals2){
                return intervals1[0] - intervals2[0];
            }
        });
        int[] dp = new int[n];
        Arrays.fill(dp, 1);
        for(int i=1; i<n; i++){
            for(int j=0; j<i; j++){
                if (intervals[j][1] <= intervals[i][0]){
                    dp[i] = Math.max(dp[i], dp[j]+1);
                }
            }
        }
        return n - Arrays.stream(dp).max().getAsInt();
    }
}

2.3 测试结果

• 正确但超时

2.4 复杂度

• 时间复杂度：O(n²)
• 空间复杂度：O(n)