leetcode-435 贪心算法

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

package 贪心算法;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

//给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。
public class NonOvarlappingInverals {
    private static ArrayList<Integer> list = new ArrayList<>();
    public static void main(String[] args) {
        int[][] a ={{1,2},{1,3},{2,4},{1,3},{2,6},{7,9}};
        Integer count = nonOverlappingInverals(a);
        System.out.println(count);
        System.out.println("原二维数组排序后：");
        showArrays(a);
        System.out.println("移除后的二维数组：");
        int[][] a2 = removeArrayByIndex(a, list);
        showArrays(a2);
    }

    /*/**
    * @Description:
    * @Param: [a] 二维数组
    * @return: java.lang.Integer
    * @Date: 2021/4/25
    */
    public static Integer nonOverlappingInverals(int[][] a){
        Arrays.sort(a, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[o1.length-1] - o2[o2.length-1];
            }
        });
        //贪心算法，如果区间的最小值小于前一个区间的最大值，就移除
        int count = 0;
        int pre = a[0][1];

        for (int i = 1; i < a.length; i++) {
            if(a[i][0] < pre){
                list.add(i);
                count ++;
            }else {
                pre = a[i][1];
            }
        }

        return count;
    }
    /*/**
    * @Description: 移除数组中的某个元素
    * @Param: [a, index]
    * @return: int[]
    * @Date: 2021/4/25
    */
    public static int[][] removeArrayByIndex(int[][] initial , List list){
        Arrays.sort(initial, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[o1.length-1] - o2[o2.length-1];
            }
        });
        int size = list.size();
        if(size == 0 ){
            return initial;
        }
        int len = initial.length;
        int[][] arr2 = new int[len -1][2];
        int index = 0;
        for (int i = 0; i < list.size(); i++) {
            index += (int)list.get(i);
            if(index >= 0 && index < initial.length){
                System.arraycopy(initial,0,arr2,0,index);
                if( index < initial.length -1 ){
                    System.arraycopy(initial,index+1,arr2,index,initial.length - 1 - index);
                    initial = arr2;
                    index = -i-1;
                    arr2 = new int[arr2.length-1][2];
                }
            }
        }
        return initial;
    }
    /*/**
    * @Description: 遍历二维数组
    * @Param: [arrs]
    * @return: void
    * @Date: 2021/4/25
    */
    public static void showArrays(int[][] arrs){
        System.out.print("[");
        for (int i = 0; i < arrs.length; i++) {
            if(i == arrs.length-1){
                System.out.print(Arrays.toString(arrs[i]));
            }else {

                System.out.print(Arrays.toString(arrs[i]));
                System.out.print(",");
            }
        }
        System.out.println("]");


    }
}