leetcode 435. 无重叠区间

@(labuladong的算法小抄)[贪心]

leetcode 435. 无重叠区间

题目描述

解题思路

参考：贪心算法之区间调度问题

将数组按end升序排列

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if (intervals.length == 0) return 0;
        /* 将数组按end升序排列 */
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        });
        /* 表示不重叠区间的数量，初始化为至少有一个区间不重叠 */
        int cnt = 1;
        /* 初始化为最早结束的end */
        int x_end = intervals[0][1];

        for (int[] interval : intervals) {
            int start = interval[0];
            /* 如果发生重叠，直接跳过；如果没有重叠，则更新 */
            if (start >= x_end) {
                x_end = interval[1];
                /* 找到下一个区间了 */
                cnt++;
            }
        }
        return intervals.length - cnt;
    }
}

将数组按start降序排列

该方法是上一方法的镜像。

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if (intervals.length == 0) return 0;
        /* 将数组按start降序排列 */
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o2[0] - o1[0];
            }
        });
        /* 表示不重叠区间的数量，初始化为至少有一个区间不重叠 */
        int cnt = 1;
        /* 初始化为最晚开始的start */
        int x_start = intervals[0][0];

        for (int[] interval : intervals) {
            int end = interval[1];
            /* 如果没有发生重叠，则更新 */
            if (end <= x_start) {
                x_start = interval[0];
                /* 找到下一个区间了 */
                cnt++;
            }
        }
        return intervals.length - cnt;
    }
}

将数组按start升序排列

区别是如果发生重叠，保留最小的那个end, 保证给后面的留下更多的空间

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if (intervals.length == 0) return 0;
        /* 将数组按start升序排列 */
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        /* 表示不重叠区间的数量，初始化为至少有一个区间不重叠 */
        int cnt = 1;
        /* 初始化为最早开始的start */
        int x_end = intervals[0][1];

        for (int[] interval : intervals) {
            int start = interval[0];
            /* 如果没有发生重叠，则更新 */
            if (x_end <= start) {
                x_end = interval[1];
                /* 找到下一个区间了 */
                cnt++;
            }
            /* 如果发生重叠，保留最小的那个end, 保证给后面的留下更多的空间*/
            else {
                x_end = Math.min(x_end, interval[1]);
            }
        }
        return intervals.length - cnt;
    }
}