LeetCode T452 用最少数量的箭引爆气球——贪心法

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

题目描述

来源：力扣（LeetCode）
链接：题目链接

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

一支弓箭可以沿着 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

贪心法

所谓贪心算法是指，在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，它所做出的仅仅是在某种意义上的局部最优解。
贪心算法没有固定的算法框架，算法设计的关键是贪心策略的选择。必须注意的是，贪心算法不是对所有问题都能得到整体最优解，选择的贪心策略必须具备无后效性（即某个状态以后的过程不会影响以前的状态，只与当前状态有关。）

贪心法虽然不能总是取得整体最优解，但并不是完全不可以使用，**贪心策略一旦经过证明成立后，它就是一种高效的算法。**比如，求最小生成树的Prim算法和Kruskal算法都是漂亮的贪心算法。因此，使用贪心算法之前，最关键的就是要证明，对于题目的最优解，是可以由局部最优解所拼凑组合出来的。在证明了这一点后，就可以通过贪心法来求得问题的最优解。

题目分析

假设有如下气球：
[1,3]，[1,2]，[1,4]，[2,9]，[3,10]
对于题目中的每一个气球，其最终都是要戳破的，因此，每个气球的直径范围内必定需要有一只箭，例如根据第一个气球[1,3]，我们可以得知[1,3]区间内必定有一只箭。
虽然[1,3]区间内必定有一只箭，但是箭放在[1,3]的哪里呢，那肯定是想放在能戳破更多其他气球的地方（1号气球肯定是会被戳破了），因此，我们可以看与1号气球位置相邻的其他气球，（示例3中的2号气球[1,2]），发现放在[1,2]区间上可以戳破两个，因此，这只箭在[1,3]范围内最好的位置就在[1,2]上了。
以此类推，我们再在[1,2]的范围内寻找是否有其他相邻气球，发现3号气球[1,4]也相邻，因此，再取[1,2]和[1,4]的集合，更新箭的位置[1,2]；
我们再在[1,2]的范围内寻找是否有其他相邻气球，发现已经没有了，于是这只箭的位置就确定在了[1,2]这个位置，并且它能戳破1，2，3三个气球。
接下来通过相同的步骤寻找第二只箭的位置，锁定在了[3,9]上，并且能够戳破4，5两个气球，至此所有气球都能被戳破，得出结果；

因此我们要做的是将相邻的气球放在一起，这样在遍历的时候能够方便我们判断，我们可以以每个气球的左直径所在位置来进行排序，使得在遍历时能够更方便的访问到相邻气球集合。

java代码如下：

    public int findMinArrowShots(int[][] points) {
        quick_sort(points,0,points.length-1);
        int res = 0;
        int[] ballon = new int[2];
        int lidx = 0;
        int ridx = 0;
        for(int i = 0 ;i<points.length;i++){
            ballon = points[i];
            lidx = ballon[0];
            ridx = ballon[1];
            boolean cantogether = true;
            while(cantogether==true){
                if(i==points.length-1){break;}
                int[] nextballon = points[i+1];
                //当前气球集合跟下一个气球没有交集
                if(nextballon[0]>ridx){
                    break;
                }
                //如果有交集，则nextballon可以加入当前气球集合，用同一只箭戳破，箭能选择的范围为[lidx,ridx]
                else{
                    lidx = Math.max(lidx,nextballon[0]);
                    ridx = Math.min(ridx,nextballon[1]);
                    i++;
                }

            }
            res++;
        }

        return res;
    }
    //快速排序法
    public void quick_sort(int[][] a,int left,int right){
        if(left > right){
            return;
        }
        int i = left ;
        int j = right;
        int[] temp = a[left];
        while(i != j){
            while(i<j && a[j][0]>=temp[0]){
                j--;
            }
            while(i<j && a[i][0]<=temp[0]){
                i++;
            }
            if(i < j){
                int[] temp1 = Arrays.copyOf(a[i],2);
                a[i] = a[j];
                a[j] = temp1;
            }
        }
        int[] kk = a[i];
        a[i] = temp;
        a[left] = kk;
        quick_sort(a,left,i-1);
        quick_sort(a,j+1,right);
    }