代码随想录算法训练营第三十五天| 860.柠檬水找零、406.根据身高重建队列、452.用最少数量的箭引爆气球

系列文章目录

---

---

860.柠檬水找零

贪心算法

bills[i] 不是 5 就是 10 或是 20，故找零只分为3种情况：

• 情况一：账单是5，直接收下；
• 情况二：账单是10，消耗一个5，增加一个10；
• 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5。

情况一，情况二，都是固定策略，情况三逻辑也不复杂甚至感觉纯模拟就可以了，其实情况三这里是有贪心的。局部最优：遇到账单20，优先消耗美元10，完成本次找零。全局最优：完成全部账单的找零。局部最优可以推出全局最优。

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int fiveSum = 0;
        int tenSum = 0;
        for (int i = 0; i < bills.length; i++) {
            if (bills[i] == 5) {
                fiveSum++;
            } else if (bills[i] == 10) {
                tenSum++;
                fiveSum--;
            } else if (bills[i] == 20) {
                if (tenSum > 0) {
                    tenSum--;
                    fiveSum--;
                } else {
                    fiveSum -= 3;
                }
            }
            if (fiveSum < 0) return false;//不用判断tenSum是否<0，因其在>0时才会做--操作
        }
        return true;
    }
}

---

406.根据身高重建队列

贪心算法

（1）本题有两个维度，h和k，看到这种题目一定要想如何确定一个维度，然后再按照另一个维度重新排列。如果两个维度一起考虑一定会顾此失彼。（与【135. 分发糖果】有点像）
（2）思路：先按身高 h 从大到小排序，如果身高相同，则k小的站前面；排完序后，再依照 k 调整顺序。局部最优：优先按身高高的people的k来插入，插入操作过后的people满足队列属性。全局最优：最后都做完插入操作，整个队列满足题目队列属性。局部最优可推出全局最优。
（3）关键：按照身高降序排序后，优先按身高高的people的k来插入，其中，Linkedlist.add(index, value)，会将value插入到指定index里。即使将后面的数组调整到前面，也不会影响前面的 k ，因为前面的肯定比后面的高。
（4）将LinkedList链表中的数据存到二维数组中的方法：

• 使用for循环：

  int[][] res = new int[list.size()][];
  for (int i = 0; i < list.size(); i++) {
      res[i] = (int[]) list.get(i);
  }
  

• 直接使用LinkedList的toArray(T[] a)方法，该方法是重新接口Collection的方法，故实现Collection接口的都能使用以下两种方法：

• 

  int[][] res = new int[list.size()][];
  list.toArray(res);
  

对身高使用冒泡排序（耗时）

import java.util.LinkedList;
class Solution {
    public int[][] reconstructQueue(int[][] people) {
        //冒泡排序(按身高从大到小排）
        for (int i = 0; i < people.length - 1; i++) {
            for (int j = 0; j < people.length - 1 - i; j++) {
                if (people[j][0] < people[j + 1][0]) {//从大到小排序
                    int[] temp = new int[2];
                    temp = people[j + 1];//交换一维数组
                    people[j + 1] = people[j];
                    people[j] = temp;
                }else if(people[j][0] == people[j + 1][0]){//在身高h的狀況下，會根据k值升序排列
                    if(people[j][1] > people[j + 1][1]){
                        int[] temp = new int[2];
                        temp = people[j + 1];//交换一维数组
                        people[j + 1] = people[j];
                        people[j] = temp;
                    }
                }
            }
        }
        LinkedList list = new LinkedList();
        for (int i = 0; i < people.length; i++) {
            list.add(people[i][1], people[i]);//按照从大到小排序后的数组，根据k值来加入list中
        }
        //将LinkedList链表中的数据存到二维数组中
        //①使用for循环
        int[][] res = new int[list.size()][];
        for (int i = 0; i < list.size(); i++) {
            res[i] = (int[]) list.get(i);
        }
        return res;
    }
}

使用Arrays类的sort对数组进行排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
class Solution {
    public int[][] reconstructQueue(int[][] people) {
        //根据身高从大到小排
        /*Arrays.sort(people, new Comparator<int[]>() {//使用匿名内部类
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0] == o2[0]) return o1[1] - o2[1];//在身高相同的情况下，会根据k值从小到大（升序）排列
                return o2[0] - o1[0];//否则根据身高的从大到小排序
            }
        });*/
        Arrays.sort(people, (a, b) -> {
            if (a[0] == b[0]) return a[1] - b[1];//在身高相同的情况下，会根据k值从小到大（升序）排列
            return b[0] - a[0];//否则根据身高的从大到小排序
        });

        //对排完序的数组先按身高高的做插入工作，需要借助链表来完成，
        // LinkedList的增删操作比ArrayList效率高
        LinkedList<int[]> list = new LinkedList<>();
        for (int i = 0; i < people.length; i++) {
            list.add(people[i][1], people[i]);//`Linkedlist.add(index, value)`，会将`value`插入到指定`index`里
        }
        //将LinkedList链表中的数据存到二维数组中
        //②直接使用LinkedList的toArray(T[] a)方法
        int[][] res = new int[list.size()][];
        list.toArray(res);
        return res;
        //return list.toArray(new int[list.size()][]);
    }
}

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

贪心算法

（1）局部最优：当气球出现重叠，一起射，所用弓箭最少。全局最优：把所有气球射爆所用弓箭最少。
（2）为了让气球尽可能的重叠，需要对数组进行排序。可以按照气球起始位置排序也可以按照气球终止位置排序，只不过对应的遍历顺序不同。
（3）以按照气球的起始位置排序为例，需要从前向后遍历气球数组，靠左尽可能让气球重复。在遍历的过程中，判断当前气球与前一个气球是否重叠，如果重叠则更新当前气球的右边界为重叠气球的最小右边界，并跳过当前气球，只有当前气球的左边界>前一个气球的右边界时（题目中说的是：满足 xstart ≤ x ≤ xend，则该气球会被引爆。说明两个气球挨在一起不重叠也可以一起射爆），才需要增加箭数。
（3）注：在按照气球的起始位置排序时，如果使用：

        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });
        /*Arrays.sort(point, (a, b) -> {
            return a[0] - b[0];
        });*/

时，会发生溢出，因取值范围是-231 <= xstart < xend <= 231 - 1，即int的范围，如[[-2147483646,-2147483645],[2147483646,2147483647]]在o1[0] - o2[0]时超出 int 类型的范围，从而导致错误的比较的结果。
解决方法：
①用long来接受两数的差值，防止超出 int 类型的范围，如果差值<0则返回-1，差值>0则返回1：

        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                long res = (long) o1[0] - o2[0];
                if (res < 0) return -1;
                else if (res > 0) return 1;
                else return 0;
            }
        });

在进行差值运算时，long res = (long) o1[0] - o2[0];，o1[0] - o2[0] 的结果是一个 int 类型的值，需要在进行减法运算之前，将 int 类型的值转换为 long 类型，以避免溢出。
②使用Integer.compare防止整数溢出，该方法会自动处理整数溢出的情况。因：

        /*Arrays.sort(points, (a, b) -> {
           return Integer.compare(a[0],b[0]);
        });*/
        Arrays.sort(points,(a, b) -> Integer.compare(a[0],b[0]));//Lambda表达式省略写法

按照气球的起始位置排序

import java.util.Arrays;
import java.util.Comparator;
class Solution {
    public int findMinArrowShots(int[][] points) {
        //按照起始位置从小到大排序
        //以下方法会整数溢出
        /*Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        });*/
        /*Arrays.sort(point, (a, b) -> {
            return a[0] - b[0];
        });*/
        //解决方法①，用long接收：
        /*Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                long res = (long) o1[0] - o2[0];
                if (res < 0) return -1;
                else if (res > 0) return 1;
                else return 0;
            }
        });*/
        //Integer.compare会自动处理整数溢出
        /*Arrays.sort(points, (a, b) -> {
           return Integer.compare(a[0],b[0]);
        });*/
        Arrays.sort(points,(a, b) -> Integer.compare(a[0],b[0]));//Lambda表达式省略写法
        int res = 1;//1 <= points.length，至少需要1支箭
        //遍历气球
        // 判断当前气球与前一个气球是否重叠，
        // 如果重叠则更新当前气球右边界为重叠气球的最小右边界，并跳过当前气球，
        // 只有当前气球的左边界>前一个气球的右边界时，才需要增加箭数
        for (int i = 1; i < points.length; i++) {
            if (points[i][0] > points[i - 1][1]) {//无重叠
                res++;// 需要一支箭
            } else {//重叠
                points[i][1] = Math.min(points[i - 1][1], points[i][1]);// 更新重叠气球最小右边界
            }
        }
        return res;
    }
}

按照气球终止位置排序

import java.util.Arrays;
class Solution {
    public int findMinArrowShots(int[][] points) {
        //按照终止位置从小到大排序
        Arrays.sort(points, (a, b) -> Integer.compare(a[1], b[1]));
        int res = 1;
        for (int i = points.length - 2; i >= 0; i--) {//从后往前遍历
            if (points[i][1] < points[i + 1][0]) {//前一个节点的右边界小于后一个节点的左边界(无重叠)
                res++;
            } else {//有重叠
                //更新最大左边界（即靠右的左边界）
                points[i][0] = Math.max(points[i + 1][0],points[i][0]);
            }
        }
        return res;
    }
}

---