代码随想录Day_35打卡

①、柠檬水找零

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

事例：

输入：bills = [5,5,5,10,20]
输出：true
解释：
前 3 位顾客那里，我们按顺序收取 3 张 5 美元的钞票。
第 4 位顾客那里，我们收取一张 10 美元的钞票，并返还 5 美元。
第 5 位顾客那里，我们找还一张 10 美元的钞票和一张 5 美元的钞票。
由于所有客户都得到了正确的找零，所以我们输出 true。

思路：

        这道题其实可以直接模拟生活场景，利用常识解决。对于找零，只有5和10块面值的钞票有作用，且5元的找零作用比10元的大，因为10元只对最大面值20元找零有用，因此，遍历bills，记录5元和10元钞票的数量，当遇到10元时，5元数量-1，10元+1；当遇到20元时，尽量用10元钞票找零，即10元大于0的情况下，10元-1 5元-1，若无10元钞票，则5元 - 3，当出现5元数量小于0的情况，则说明无法找零，直接终止，遍历完成，则返回true。

代码：

public boolean lemonadeChange(int[] bills) {
        int[] help = new int[3]; //辅助数组 表示 5 10 20金额的剩余量
        for(int i = 0;i < bills.length;i++){
            if(bills[i] == 5) help[0]++;
            else if(bills[i] == 10){
                help[1]++;
                help[0]--;
            }else{
                help[2]++;
                if(help[1] > 0){
                    //先用10块的
                    help[1]--;
                    help[0]--;
                }else{
                    help[0] -= 3;
                }
            }
            if(help[0] < 0) return false;
        }
        return true;
    }

②、根据身高重建队列

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

事例：

输入：people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]
输出：[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]
解释：
编号为 0 的人身高为 5 ，没有身高更高或者相同的人排在他前面。
编号为 1 的人身高为 7 ，没有身高更高或者相同的人排在他前面。
编号为 2 的人身高为 5 ，有 2 个身高更高或者相同的人排在他前面，即编号为 0 和 1 的人。
编号为 3 的人身高为 6 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
编号为 4 的人身高为 4 ，有 4 个身高更高或者相同的人排在他前面，即编号为 0、1、2、3 的人。
编号为 5 的人身高为 7 ，有 1 个身高更高或者相同的人排在他前面，即编号为 1 的人。
因此 [[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]] 是重新构造后的队列。

思路：

        这道题和之前的糖果分配类似，排序有两个因素干扰，因此，我们先根据其中一个元素排序，然后再遍历数组，根据另一个元素排序即可。

        首先理解两个元素的作用，元素k意味着前面有多少个人身高大于等于他，而身高的排序明显会影响k的值，故得先按照身高排序，选择降序排序，因为降序排完后，右边的people身高都是小于当前身高，此时，右边的人怎么往左边插入，都不会影响当前people的k值。

        第一次排序：按身高降序排，若身高相等，再按k的升序排，如7,0必须在7,1前面。

        第二次排序：身高降序排完后，再for循环遍历数组，此时k的价值就体现出来了，k意味着当前people在数组[0,i]之间的位置，因为身高已降序排序，前面所有人的身高均大于当前身高值，把k当索引插入，则确保前面只有k个人身高大于等于他。

代码：

public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]){
                    //身高相同 用k值升序排序
                    return o1[1] - o2[1];
                }
                //身高降序排序
                return o2[0] - o1[0];
            }
        });
        LinkedList<int[]> list = new LinkedList<>();
        for(int i = 0;i < people.length;i++){
            //根据k值选择插入位置
            int k = people[i][1];
            list.add(k,people[i]);
        }
        int[][] res = list.toArray(new int[][]{});
        return res;
    }

③、用最少数量的箭引爆气球

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

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

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

事例：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：气球可以用2支箭来爆破:
-在x = 6处射出箭，击破气球[2,8]和[1,6]。
-在x = 11处发射箭，击破气球[10,16]和[7,12]。

思路：

        首先将points数组按照左边界降序排序，创建left记录当前重复集合的左边界，创建right记录当前重复集合的右边界，遍历数组，当遇到气球在里面时(气球的左半径小于等于右边界)，更新边界(缩小边界)，当气球不在区间里面时，需要先发射一支箭引爆前面集合里的气球(res++)，边界更新为当前气球的直径范围，当遍历完数组后，其实还有最后一个重复集合气球没被引爆，最终返回res + 1。

代码：

public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[0] == o2[0]){
                    if(o1[1] < o2[1]) return -1;
                    else return 1;
                }
                if(o1[0] < o2[0]) return -1;
                else return 1;
            }
        });
        int res = 0; //箭的数量
        //左右边界
        int left = points[0][0];
        int right = points[0][1];
        int count = 1; //重合的数量
        for(int i = 1;i < points.length;i++){
            int[] point = points[i];
            if(point[0] <= right){
                //重合了
                left = Math.max(left,point[0]);
                right = Math.min(right,point[1]);
                count++;
            }else{
                //击破之前重合的气球
                res++;
                count = 1;
                //重新确定左右边界
                left = point[0];
                right = point[1];
            }
        }
        res++;
        return res;
    }

参考：代码随想录 (programmercarl.com)