代码随想录训练营第34天| 860.柠檬水找零、406.根据身高重建队列、452. 用最少数量的箭引爆气球-优快云博客

文章介绍了三道LeetCode编程题目，涉及数组操作、排序算法（如快速排序的变种）和优化策略，分别解决找零问题、根据身高重建队列和用最少箭矢引爆气球问题，展示了算法思维在实际问题中的应用。

860.柠檬水找零

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int[] dollar = new int[2];
        for(int i = 0; i < bills.length; ++i) {
            switch (bills[i]) {
                case 5:
                    ++dollar[0];
                    break;
                case 10:
                    if(dollar[0] == 0) {
                        return false;
                    }else {
                        --dollar[0];
                        ++dollar[1];
                    }
                    break;
                default:
                    if(dollar[1] >= 1 && dollar[0] >= 1) {
                        --dollar[1];
                        --dollar[0];
                    } else if(dollar[0] >= 3){
                        dollar[0] -= 3;
                    }else {
                        return false;
                    }
                    break;
            }
        }
        return true;
    }
}

406.根据身高重建队列

题目链接：406. 根据身高重建队列 - 力扣（LeetCode）

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, (x1, x2) -> {
            if (x1[0] != x2[0]) {
                return x2[0] - x1[0];
            } else {
                return x1[1] - x2[1];
            }
        });
        int[][] ans = new int[people.length][2];
        int e = 0;
        for(int i = 0; i < people.length; ++i) {
            int a = 0;
            for(int j = 0; j < people.length; ++j) {
                if(people[j][0] < 0) {
                    ++a;
                }
                if(a == people[j][1]) {
                    e = j;
                }
            }
            ans[i][0] = people[e][0];
            ans[i][1] = people[e][1];
            people[e][0] = -1;
        }
        return ans;
    }
}

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

题目链接：452. 用最少数量的箭引爆气球 - 力扣（LeetCode）

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, new Comparator<int[]>() {
            public int compare(int[] point1, int[] point2) {
                if (point1[1] > point2[1]) {
                    return 1;
                } else if (point1[1] < point2[1]) {
                    return -1;
                } else {
                    return 0;
                }
            }
        });
        int ret = 1;
        for (int i = 0; i < points.length - 1; ++i) {
            if (points[i][1] >= points[i + 1][0]) {
                points[i + 1][0] = points[i][1];
                points[i + 1][1] = Math.min(points[i + 1][1], points[i][1]);
            } else {
                ++ret;
            }
        }
        return ret;
    }
}

最后两道题，主要考察的是重写compare，思维难度不高