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

题目链接：● 860.柠檬水找零

代码随想录

 看完代码随想录之后的想法：

 这道题使用贪心的方法：

我们用a记录商店拥有面值为5的数量，用b记录商店拥有面值为10的数量，我们不需要记录商店所拥有面值为20的数量；

我们遍历bills

当顾客拿出5美元时，我们直接收下，那么a+1；

当顾客拿出10美元时，我们首先判断有没有5美元，如果没有就返回false，如果有的话，a-1，b+1

当顾客拿出20美元时，因为5美元可以用来找10，20，用处比较多，因此，我们尽可能保留5美元，我们首先选用一张10美元，一张5美元的进行找零，如果不能的话，再选用3张5美元进行找零，如果还不行的话，就return false;

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int a = 0, b = 0;
        for(int i = 0; i < bills.length; i++) {
            if(bills[i] == 5) 
                a++;
            else if(bills[i] == 10) {
                if(a <= 0) 
                    return false;
                else {
                    a -= 1;
                    b += 1;
                }                    
            }else {
                if(b >=1 && a >= 1) {
                    b -= 1;
                    a -= 1;
                }else if(a >= 3){
                    a -= 3;
                }else 
                    return false;
            }
        }
        return true;
    }
}

题目链接:406.根据身高重建队列 

代码随想录

看完代码随想录之后的想法：

这道题我们和分糖果的题很像，我们都是先利用一个维度，再利用另一个维度；（h,k)

我们首先按照身高从大到小排序（如果身高相等k小的放在前面）

然后我们在根据k进行放置，k为多少，这个人就放到第k个；

因为对于一个人来说，k的值代表前面有k个人比他高，我们已经按照身高排过序了，说明前面的人都比他高，说明，这个人前面就有k个，因此这个人就放到第k位；

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, (a,b) -> {
            if(a[0] == b[0]) return a[1] - b[1];
            return b[0] - a[0];
        });
        LinkedList<int[]> res = new LinkedList<>();
        for(int i = 0; i < people.length; i++) 
            res.add(people[i][1], people[i]);
        return res.toArray(new int[people.length][]);
    }
}

题目链接：452. 用最少数量的箭引爆气球

代码随想录

 自己的想法

首先对这个points进行排序1，if当a[0] = b[0],根据a[1] b[1]，从小到大哦进行排列；2else 根据a[0]b[0] 从小到大进行排列；

同时我们设置两个变量prevalue,curvalue,记录我们射箭的范围，如果我们下一次point[i]存在数在[prevalue, curvalue]，那么就满足一支箭同时射穿多个气球，同时我们需要更行prevlaue, curvalue

else,不满足同时射穿，那么我们就count++;

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, (a,b) -> {
            if(a[0] == b[0]) return a[1] - b[1];
            return a[0] - b[0];
        });
        int count = 1;
        int prevalue = points[0][0];
        int curvalue =points[0][1];
        for(int i = 1; i < points.length; i++) {
            if((points[i][0] <=  curvalue
            && points[i][1] >= curvalue) ||
            (points[i][0] >= prevalue && points[i][1] <= curvalue)) {
                prevalue = Math.max(prevalue, points[i][0]);
                curvalue = Math.min(curvalue, points[i][1]);
            }            
            else {
                curvalue = points[i][1];
                count++;
            }
        }
        return count;
    }
}

看完代码随想录之后的想法：

原来我们不需要判断point[i]左边界，因为我们已经排好序了，如果我们的point[i][0] < 上个气球的"右边界"就可以满足条件了；

如果气球i和气球i-1不挨着，count++，

else 我们更新point[i][1] 

points[i][1] = Math.min(points[i][1], points[i - 1][1]);

class Solution {
    public int findMinArrowShots(int[][] points) {        
        Arrays.sort(points, (a,b) -> Integer.compare(a[0], b[0]));
        int count = 1;
        for(int i = 1; i < points.length; i++) {
            if(points[i][0] > points[i - 1][1]) {
                count++;
            }            
            else {
                points[i][1] = Math.min(points[i][1], points[i - 1][1]);
            }
        }
        return count;
    }
}

总结：

今天学习了一些贪心基础算法，背了半小时代码，学习了一些计组；加油