452-用最少数量的箭引爆气球

452-用最少数量的箭引爆气球

在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend，
且满足 xstart ≤ x ≤
xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

• 输入：points = [[10,16],[2,8],[1,6],[7,12]]
• 输出：2
• 解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球

示例 2：

• 输入：points = [[1,2],[3,4],[5,6],[7,8]]
• 输出：4

示例 3：

• 输入：points = [[1,2],[2,3],[3,4],[4,5]]
• 输出：2

示例 4：

• 输入：points = [[1,2]]
• 输出：1

示例 5：

• 输入：points = [[2,3],[2,3]]
• 输出：1

提示：

• 0 <= points.length <= 10^4
• points[i].length == 2
• -2^31 <= xstart < xend <= 2^31 - 1

二维数组排序

使用Arrays.sort()函数

sort(T[] a, Comparator<? super T> c) --根据指定的比较器引发的顺序对指定的对象数组进行排序。

Arrays.sort(T[], new Comparator<T>() {
	public int compare(T a, T b){
		return fa - fb;
	}
});

• fa，fb 标识自定义排序方式。
• 默认为从小到大排序，参数b-参数a：代表从大到小排序

   //二维数组排序        
   Arrays.sort(T[], new Comparator<T[]>() {
        @Override
        public int compare(T[] o1, T[] o2) {
            //从大到小排序，如果第一位相同，则根据第二位排序
            return o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0];
        }
    });

使用Lambda表达式

使用Lambda表达式的方式对Comparator比较器进行简写（JDK1.8+）

	int[][] intervals = {{2,3,4,5},{2,9,7,3},{4,5,1,5},{3,7,1,2},{6,7,3,4}};
	Arrays.sort(intervals, (o1, o2) -> {
	return o1[2] - o2[2];
});

思路：

因为弓箭一旦被射出之后，可以无限地前进。

所有我们只需要在气球重叠的区域只使用一支弓箭。达到所需的弓箭最少的数量。

又因为给定的二维数组是乱序的，首先需要进行排序，才能将重叠的气球统计出来。

• 将二维数组排序后，以最小的右边界由左向后遍历
• 找出最多的气球后，需要的弓箭加一，同时更新最小右边界

  class Solution {
        public int findMinArrowShots(int[][] points) {
        
    
        if(points.length == 0) {
            return 0;
        }
        //排序
        Arrays.sort(points,(o1,o2)-> Integer.compare(o1[0],o2[0]));
    
        int result = 1; //弓箭数量
        for(int i = 1;  i < points.length ; i++){
            if(points[i][0] > points[i - 1][1]){ //左边界大于前一气球的最小右边界，需要将弓箭加一
                result++;
            }else{                               //气球起始左边小于前一气球的最小右边界，更新最小右边界。
                points[i][1] = 
                Math.min(points[i][1],points[i -1][1]);
            }
        }
        return result;
    
    
        }
    }