leetcode刷题：贪心算法12（用最少数量的箭引爆气球）

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

贪心思想，先对整个二维数组进行排序，根据第一列优先升序，第二列为第二关键字，也升序。
从第一个气球开始计算当前气球的最右边位置 point[i][0]。然后遍历剩下的气球中的起点start,反是start <= point[i][0]都是可以连续引爆的。先初始化总需要箭矢数，为数组长度，最多也就每个气球一个箭矢。如果连续引爆，就箭矢数量-1.然后下次 i 就多走一位，因为这个气球已经引爆了。但要注意这种测例 [1,9] [2,4] [6,8] 。至少需要两个，所以还要记录遇到的最小右边界，到这里一个箭矢能连续击穿的气球数量达到了极致。然后就得 i 后移了。

package com.programmercarl.greed;

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

/**
 * @ClassName FindMinArrowShots
 * @Descriotion TODO
 * @Author nitaotao
 * @Date 2022/7/16 17:20
 * @Version 1.0
 * 452. 用最少数量的箭引爆气球
 * https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons/
 **/
public class FindMinArrowShots {
    public int findMinArrowShots(int[][] points) {
        //先对数组进行排序
        //以x start 升序
        //如果 x start 相同，以 x end 升序
//        Arrays.sort(points, (o1, o2) -> {
//            if (o1[0] == o2[0]) {
//                return o1[1] - o2[1];
//            } else {
//                return o1[0] - o2[0];
//            }
//        });
        //之前的排序面对 [[-2147483646,-2147483645],[2147483646,2147483647]] 会溢出
        //按左边界排序，升序   也不行，需要对第二个字段也升序
//        Arrays.sort(points, Comparator.comparingInt(a -> a[0]);


        Arrays.sort(points, (o1, o2) -> {
            if (o1[0] == o2[0]) {
                // 升序  o1[1]-o2[1]   <0
                // 即  o1[1]<o2[1]
                // Integer.compare(o1[1], o2[1])
                // 如果 o1[1]<o2[1]
                // Integer.compare(o1[1], o2[1]) 返回 -1 也<0
                return Integer.compare(o1[1], o2[1]);
            } else {
                return Integer.compare(o1[0], o2[0]);
            }
        });


        int result = points.length;
        for (int i = 0; i < points.length - 1; ) {
            int index = i + 1;
            int temp = 1;
            int minRight = Integer.MAX_VALUE;
            //如果两个气球有重合的地方，箭 - 1
            //左边的气球的右侧在右边气球的右侧，打两个气球中间
            for (int j = index; j < points.length; j++) {
                if (points[j][0] > minRight) {
                    //如果超出最小右边界
                    break;
                }
                if (points[i][1] >= points[j][0]) {
                    if (points[j][1] < minRight) {
                        minRight = points[j][1];
                    }
                    //需要记录最小右边界
                    result--;
                    //新的i的位置
                    //i+=temp
                    temp++;

                } else {
                    break;
                }
            }
            i += temp;
        }
        return result;
    }

    public static void main(String[] args) {
        int[][] arr = new int[7][];
        arr[0] = new int[]{9, 12};
        arr[1] = new int[]{1, 10};
        arr[2] = new int[]{4, 11};
        arr[3] = new int[]{8, 12};
        arr[4] = new int[]{3, 9};
        arr[5] = new int[]{6, 9};
        arr[6] = new int[]{6, 7};
        System.out.println(new FindMinArrowShots().findMinArrowShots(arr));
    }
}

有一说一，这题某些测例我就不点名说了，恶心归恶心，但锻炼了我们的排序能力，还是好的。