LeetCode 435 Non-overlapping Intervals

题目

Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Note:

1. You may assume the interval's end point is always bigger than its start point.
2. Intervals like [1,2] and [2,3] have borders "touching" but they don't overlap each other.

Example 1:

Input: [ [1,2], [2,3], [3,4], [1,3] ]
Output: 1
Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.

Example 2:

Input: [ [1,2], [1,2], [1,2] ]
Output: 2
Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.

Example 3:

Input: [ [1,2], [2,3] ]
Output: 0
Explanation: You don't need to remove any of the intervals since they're already non-overlapping.

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

---

解法思路（一）

关于排列与组合

• 排列和组合都是从给定的序列中，选几个元素；
• 选的元素的个数不能大于序列的长度；
• 排列对选出的元素的位置有要求，比如选出 3 个元素，3 个元素的相对位置的不同，是不同的排列；
• 组合对选出的元素的位置没有要求，比如选出 3 个元素，3 个元素的相对位置的不同，是相同的排列；
• 排列的递归树中，当前层选中了一个元素，下一层元素在剩余的元素中选；
• 组合的递归树中，当前层选中了一个元素，下一层元素在上一层选中的元素之后的元素中选；

暴力解法怎么解？

• 找出一组区间的所有组合，判断每个组合是否重叠，在不重叠的组合中，找出区间最多的组合，其包含的区间的个数 m，用给出的区间序列的长度 n 减去 m 得解；
• 时间复杂度是：O(2ⁿ * n)；

为什么是组合不是排列？

• 比如给定的区间序列是 [1,2], [3,4], [5,6]，排列 [1,2], [3,4] 和 [3,4], [1,2] 都是去掉了区间 [5,6] 后得到的排列，不同的排列在这道题的场景下没有区别，所以，这里用组合而不是排列；

如何判断一组区间是否重叠？

• 先将一组区间排序；
• 然后后面的区间的左边界是否大于等于前一个区间的右边界；

如何将一组区间排序？

• 对区间的起始点进行排序；
• 如果区间的起始点相等，用区间的终止点排序；

动态规划的状态如何定义？

• memo[i] 表示使用 intervals[0...i] 的区间能构成的最长不重叠区间序列的长度；

解法实现（一）

代码实现

• 注意看二维数组是怎么比较的，通过自定义比较器；
• 注意 memo 的语义，是能构成的最大不重叠区间的长度，不是要删除的区间的个数，相应的返回值是 intervals.length - res;

package leetcode._435;

import java.util.Arrays;
import java.util.Comparator;

public class Solution435_1 {

    public int eraseOverlapIntervals(int[][] intervals) {

        if (intervals.length == 0)
            return 0;

        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0] != o2[0]) {
                    return o1[0] - o2[0];
                }
                return o1[1] - o2[1];
            }
        });

        // 动态规划的状态定义：
        // memo[i] 表示使用 intervals[0...i] 的区间能构成的最长不重叠区间序列的长度；
        int[] memo = new int[intervals.length];
        Arrays.fill(memo, 1);

        for (int i = 1; i < intervals.length; i++)
            for (int j = 0; j < i; j++)
                if (intervals[i][0] >= intervals[j][1])
                    memo[i] = Math.max(memo[i], 1 + memo[j]);

        int res = 0;
        for(int i = 0; i < memo.length; i++)
            res = Math.max(res, memo[i]);

        return intervals.length - res;
    }

    public static void main(String[] args) {

//        int [][] intervals = {{1, 2}, {4, 5}, {7, 9}};
        int [][] intervals = {{1, 2}};

        Solution435_1 s = new Solution435_1();
        int res = s.eraseOverlapIntervals(intervals);

        System.out.println(res);
    }

}

返回 LeetCode [Java] 目录