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

参考文章
链接: 860. 柠檬水找零
链接: 406.根据身高重建队列
链接: 452. 用最少数量的箭引爆气球

860. 柠檬水找零

自己写的版本 太耗时了 16ms
时间复杂度 O(n)
空间复杂度 O(n)

class Solution {
    Map<Integer,Integer> map = new HashMap<>();
    public boolean lemonadeChange(int[] bills) {
         for(int i =0; i<bills.length; i++){
             switch(bills[i]){
                 case 5:
                    map.put(5, map.getOrDefault(5,0) + 1);
                    break;
                 case 10:
                     map.put(10, map.getOrDefault(10,0) + 1);
                    if(map.containsKey(5) && map.get(5) > 0){
                        map.put(5, map.get(5) - 1);
                    }else{
                        return false;
                    }
                    break;
                 case 20:
                    if(map.containsKey(10) && map.get(10) > 0 && map.get(5) > 0){
                      map.put(10, map.get(10) - 1);
                      map.put(5, map.get(5) - 1);
                    }else if(map.containsKey(5) && map.get(5) > 2){
                        map.put(5, map.get(5) - 3);
                    }else{
                        return false;
                    }
                    break;
             }


         }
         return true;
    }
}

优化版本 2ms
时间复杂度 O(n)
空间复杂度 O(n)

class Solution {
   
    public boolean lemonadeChange(int[] bills) {
        int five = 0, ten = 0;
         for(int i =0; i<bills.length; i++){
             // case 1
             if(bills[i] == 5){
                 five++;
             }

             // case 2
             if(bills[i] == 10){
                 ten++;
                 if(five > 0){
                     five--;
                 }else{
                     return false;
                 }
             }
             // case 3
            if(bills[i] == 20){
                if(ten > 0 && five > 0){
                    ten--;
                    five--;
                }else if(five > 2){
                    five -= 3;
                }else{
                    return false;
                }
            }
         }
         return true;
    }
}

406.根据身高重建队列

这一题和按分数分发糖果的题很想，都是由两个维度需要处理，遇到多个维度问题，需要从不同的维度分开处理而不是同时处理两个维度。

最终队列插入过程如下

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        LinkedList<int[]> que = new LinkedList<>(); // 用来记录最终结果
        Arrays.sort(people, (a ,b) -> {
            if(a[0] == b[0]) return a[1] - b[1]; // 当身高相同时，K值越小的往前排，K值为升序排序
            return b[0] - a[0]; // 身高不相同则身高越高的往前排，按身高降序排
        });


        for(int[] x: people){
            que.add(x[1], x); // index, value 这里的index为K的值
        }

        return que.toArray(new int[people.length][]);
    }
}

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

• 遇到的困难
  1 不知道如何表达重叠区间
  2 没有考虑到最小右边界的情况
  3 数组升序排序遇到了溢出的情况，应该用Integer内置函数

class Solution {
    public int findMinArrowShots(int[][] points) {
        // Edge case
        if(points.length == 0) return 0;
         // 先按照气球的左边界排序, 按升序排序，从小到大
         Arrays.sort(points, (a,b) -> Integer.compare(a[0], b[0]));
         int arrow = 1; // 如果气球数大于1则至少需要1支箭
         for(int i = 1; i<points.length; i++){
             if(points[i][0] > points[i-1][1]){
                 arrow++; // 如果这个气球的左边界大于上一个气球的右边界则不重叠
             }else {
                 points[i][1] = Math.min(points[i][1], points[i-1][1]); // 更新重叠气球最小右边界
             }
         }
         return arrow;
    }
}