算法练习贴--46--无重叠区间(Java)

无重叠区间

一、题目描述

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
（题目来源：力扣（LeetCode））

注意:
   1. 可以认为区间的终点总是大于它的起点。
    2.区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。

示例 1:

输入: [ [1,2], [2,3], [3,4], [1,3] ]

输出: 1

解释: 移除 [1,3] 后，剩下的区间没有重叠。

示例 2:

输入: [ [1,2], [1,2], [1,2] ]

输出: 2

解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:
输入: [ [1,2], [2,3] ]

输出: 0

解释: 你不需要移除任何区间，因为它们已经是无重叠的了。

二、解决方法

1. 排序+替换区间(数组赋值方式移除区间)

class Solution {
    public  int eraseOverlapIntervals(int[][] intervals) {
    	//将二维数组中的每一个一维数组按数组的第一个数字排序
    	//比如：[ [1,2], [2,3], [3,4], [1,3] ]
    	//排序后：[ [1,2],[1,3],[2,3], [3,4] ]
    	Arrays.sort(intervals, new Comparator<int[]>() {
    		@Override
    		public int compare(int[] arr1, int[] arr2) {
    			return Integer.compare(arr1[0], arr2[0]);
    		}
		});
		//统计被移除的区间数
    	int count=0;
    	for (int i = 0; i < intervals.length-1; i++) {
    		//此时第一个一维数组第一个数字肯定小于或等于第二个一位数组的第一个数字(刚排序了的)
    		//此时我们分为三种情况：
    		//1.第一个一维数组第二个数字小于或等于第二个一维数组第一个数字
    		//比如：[1,2][2,3]。这种情况题目是允许的，不操作，直接进入下一次循环。
    		
    		//2.第一个一维数组第二个数字小于或等于第二个一维数组第二个数字
    		//比如:[1,2],[1,3]或[1,3],[1,3]。此时要排除第二个数组(排除大的,那么和之后的数组区间重合的几率就要小)
    		//直接将count++,将第一个数组赋值给第二个数组
    		
    		//3.第一个一维数组第二个数字大于第二个一维数组第二个数字
    		//直接将count++,此时移除第一个数组(因为我们是递增的不需要操作)，而且2,3的count++可以合并
    		if(intervals[i][1]<=intervals[i+1][0]) {
    			continue;
    		}else if(intervals[i][1]<=intervals[i+1][1]) {
    			intervals[i+1][1]=intervals[i][0];
				intervals[i+1][1]=intervals[i][1];
			}
            count++;
		}
    	return count;
    }
}

2. 排序+替换区间（用一个变量记录前一个区间范围）

package com.lxf.test;

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

public class EraseOverlapIntervals {
    public static void main(String[] args) {
        System.out.println(eraseOverlapIntervals(new int[][]{{1,2},{1,2},{1,2}}));
    }
    public static int eraseOverlapIntervals(int[][] intervals) {
    	//数组为空直接返回0
    	if(intervals.length==0) return 0;
    	//将二维数组中的每一个一维数组按数组的第一个数字排序
        Arrays.sort(intervals, (a,b)->a[0]-b[0]);
        int count=0;
        //记录前一个区间的右值(因为左值是已经排好序的)
        int right=intervals[0][1];
        for (int i = 1; i < intervals.length; i++) {
        	//如果两个区间没有重叠，右值赋值当前区间的右值，直接比较下一个区间
            if(right<=intervals[i][0]) {
                right=intervals[i][1];
                continue;
            }else if(right>intervals[i][1]) {
            	//如果当前区间包含了第一个区间，赋值右值
                right=intervals[i][1];;
            }
            //如果当前区间包含了第一个区间，右值已经在上面赋值过了，只需要count++即可
            //如果两个区间有重叠(完全包含已经在上面搞定)：只需要count++即可,反正要去掉一个区间，为什么不去掉第二个区间（和后面区间重合概率高）呢
            //另注意:[[1,3],[2,3]]这也算完全包含，但是我们还是不赋值(都是一样的，没必要)
            count++;

        }
        return count;
    }
}

3.贪心算法(官方题解)
我的思路是排序第一个数字，然后比较第二个数字。官方是排序第二个数字，比较第一个数字(官方很巧妙的是计算不要排除的，用总数减去不要排除的就是要排除的)

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if (intervals.length == 0) {
            return 0;
        }
        //将二维数组中的每一个一维数组按数组的第二个数字排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[1] - interval2[1];
            }
        });

        int n = intervals.length;
        //一维数组的右值
        int right = intervals[0][1];
        //统计不需要排除的区间数(以第一个数组开始，所以是不需要排除)
        int ans = 1;
        for (int i = 1; i < n; ++i) {
        	//如果第二个数组第一个数字比前一个数组第二个数字大于或等于，说明没重叠
        	//比如:[1,2][2,3] 或[1,2][3,4]
            if (intervals[i][0] >= right) {
                ++ans;
                right = intervals[i][1];
            }
        }
        //总的减去不需要排除的区间数就是答案
        return n - ans;
    }
}

4. 动态规划(官方题解)

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if (intervals.length == 0) {
            return 0;
        }
        //将二维数组中的每一个一维数组按数组的第一个数字排序
        Arrays.sort(intervals, new Comparator<int[]>() {
            public int compare(int[] interval1, int[] interval2) {
                return interval1[0] - interval2[0];
            }
        });
		//要比较的区间总长度
        int n = intervals.length;
        //记录冲突区间的数组
        int[] f = new int[n];
        Arrays.fill(f, 1);
        for (int i = 1; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                if (intervals[j][1] <= intervals[i][0]) {
                	//如果第二个区间和前一个区间没有冲突，当前满足区间数得按照公式去取舍，获取最佳答案
                	//dp公式：f[i] = Math.max(f[i], f[j] + 1);
                	//这一个公式把取舍每一个区间后剩余多少个区间都保留下来。				//涵盖了取舍每个区间的情况，并取剩余区间数最大的那个
                	//因为我们要剔除的区间数最小
                    f[i] = Math.max(f[i], f[j] + 1);
                }
            }
        }
        //要剔除的区间数=总长度-保留下来的区间数
        return n - Arrays.stream(f).max().getAsInt();
    }
}