[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.

这个题一眼看上去还是有点麻烦的，不知道从何入手。但是经过转换以后，就很简单了，和前面一道类似的题完全不同，这不再是一个interval的问题了，实际上就是一个活动选择问题（典型的贪心算法入门问题）。

思路：

这个题可以转化为：给定一些任务，以及它们的开始时间和结束时间。并且给定一段时间，尽可能安排多的任务（具体可见《算法导论 第三版》16.1 活动选择问题）。因此，我们首先将这些intervals按end升序排序，相同的end按照start升序排序。

很容易想到，我们希望尽可能的安排比较早结束的任务（也就是end比较小的），然后是考虑start紧跟上一个end的任务，这些任务同样是要满足end尽可能小的原则，依次类推。

因此，在我们排序以后，正好可以满以上的排序要求，很容易一次遍历得到结果。最后，总任务数量，减去排好的任务，就是要删除的任务。

代码如下，复杂度大致为O(nlogn)+O(n)=O(nlogn):

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
public class Solution {
    public int eraseOverlapIntervals(Interval[] intervals) {
        if (intervals.length < 1) {
            return 0;
        }
        Arrays.sort(intervals, new Comparator<Interval>() {
            @Override
            public int compare(Interval o1, Interval o2) {
                if (o1.end == o2.end) {
                    return o1.start - o2.start;
                } else {
                    return o1.end - o2.end;
                }
            }
        });
        int nInsert = 1;
        int nLastEnd = intervals[0].end;
        for (Interval interval : intervals) {
            if (interval.start >= nLastEnd) {
                nLastEnd = interval.end;
                nInsert++;
            }
        }
        return intervals.length - nInsert;
    }
}