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

 

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:

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.

 

M1: greedy based on start point

sort the intervals by start points, while traversing, there're 3 conditions: (1) non-overlap (2) overlap, the end point of the later interval falls before the end point of the previous one -> take the later interval, since choosing an interval of smaller width will lead to more available intervals can be accommodated (3) overlap, the end point of the later interval falls after the end point of the previous one  -> remove the later interval, take the previous one, reason same as (2)   time = O(nlogn) -- sort, space = O(logn) -- sort

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if(intervals == null || intervals.length == 0) {
            return 0;
        }
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);  // sort by start time
        int count = 0;
        int[] prev = intervals[0];
        for(int i = 1; i < intervals.length; i++) {
            if(intervals[i][0] >= prev[1]) {    // non-overlap
                prev = intervals[i];
            } else {
                if(intervals[i][1] < prev[1]) { // keep the interval with earlier end time
                    prev = intervals[i];
                }
                count++;
            }
        }
        return count;
    }
}

 

M2: greedy based on end point time = O(nlogn) -- sort, space = O(logn) -- sort

class Solution {
    public int eraseOverlapIntervals(Interval[] intervals) {
        if(intervals.length == 0) {
            return 0;
        }
        Arrays.sort(intervals, (a, b) -> (a.end - b.end));
        int end = intervals[0].end;
        int count = 1;  // non-overlapping part
        for(int i = 1; i < intervals.length; i++) {
            if(intervals[i].start >= end) {
                count++;
                end = intervals[i].end;
            }
        }
        return intervals.length - count;
    }
}