425.用最少数量的箭引爆气球 中等
问题描述
有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points
,其中points[i] = [xstart, xend]
表示水平直径在 xstart
和 xend
之间的气球。你不知道气球的确切 y 坐标。
一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x
处射出一支箭,若有一个气球的直径的开始和结束坐标为 x``start
,x``end
, 且满足 xstart ≤ x ≤ x``end
,则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后,可以无限地前进。
给你一个数组 points
,返回引爆所有气球所必须射出的 最小 弓箭数 。
示例 1:
输入:points = [[10,16],[2,8],[1,6],[7,12]]
输出:2
解释:气球可以用2支箭来爆破:
-在x = 6处射出箭,击破气球[2,8]和[1,6]。
-在x = 11处发射箭,击破气球[10,16]和[7,12]。
示例 2:
输入:points = [[1,2],[3,4],[5,6],[7,8]]
输出:4
解释:每个气球需要射出一支箭,总共需要4支箭。
示例 3:
输入:points = [[1,2],[2,3],[3,4],[4,5]]
输出:2
解释:气球可以用2支箭来爆破:
- 在x = 2处发射箭,击破气球[1,2]和[2,3]。
- 在x = 4处射出箭,击破气球[3,4]和[4,5]。
提示:
1 <= points.length <= 105
points[i].length == 2
-231 <= xstart < xend <= 231 - 1
解题思路
结合贪心的思想,使points数组中不同元素尽可能有交集,才能尽可能减少射箭的次数。
从左到右遍历points数组,如果右边界小于当前元素的左边界,说明无交集,只能新增1支箭;如果有交集,则取右边界和当前元素右边界的最小值更新右边界。
代码实现
import java.util.Arrays;
import java.util.Comparator;
class Solution {
public int findMinArrowShots(int[][] points) {
Arrays.sort(points,new Comparator<int[]>() {
// Comparator接口实现,重写compare方法较好的写法
public int compare(int[] o1, int[] o2) {
if(o1[0] != o2[0]){
return Integer.compare(o1[0],o2[0]);
}else{
return Integer.compare(o1[1],o2[1]);
}
}
});
int res=1; //对于非空的points最少需要1支箭
int i=1;
int right=points[0][1]; //定义points初始右边界
while(i < points.length){
//如果右边界小于当前元素的左边界,说明无交集,只能新增1支箭
if (right < points[i][0]) {
res++; //箭的数量+1
right=points[i][1]; //更新右边界
}else {
//如果有交集,则取右边界和当前元素右边界的最小值更新右边界
right=Integer.min(right,points[i][1]);
}
i++;
}
return res;
}
}
踩坑点
这题有个比较坑的测试例:
int[][] points={{-2147483646,-2147483645},{2147483646,2147483647}};
当我们采用如下方式进行排序时,就会出现问题:
Arrays.sort(points,(a, b)->{
if(a[0] == b[0]){
return a[1]-b[1];
}
return a[0]-b[0];
});
这种方式排序时,由于做减法的两个数都比较大,会出现溢出。例如-2147483646-2147483646会造成下溢出,这是此题很坑的一个地方。在这时,数组排序后,会变成{{2147483646,2147483647},{-2147483646,-2147483645}}的顺序,这与我们需要的不同。 可以考虑使用下面的这种方式:
Arrays.sort(points,new Comparator<int[]>() {
// Comparator接口实现,重写compare方法较好的写法
public int compare(int[] o1, int[] o2) {
if(o1[0] != o2[0]){
return Integer.compare(o1[0],o2[0]);
}else{
return Integer.compare(o1[1],o2[1]);
}
}
});
这里我查询了Integer.compare()方法的源码如下:
/**
* Compares two {@code int} values numerically.
* The value returned is identical to what would be returned by:
* <pre>
* Integer.valueOf(x).compareTo(Integer.valueOf(y))
* </pre>
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 1.7
*/
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
很明显,它使用的是“<”进行比较,就不会出现上述的溢出。