代码随想录算法训练营 Day34 | LeetCode860.柠檬水找零、LeetCode406.根据身高重建队列、 LeetCode452. 用最少数量的箭引爆气球

LeetCode860.柠檬水找零

这道题没有那么复杂的策略，就是理清楚所有的情况用代码写出来即可，记录10和5的数量。贪心的策略就是优先使用10的面值。

代码如下：时间复杂度O(n)；空间复杂度O(1).

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        int count_5=0;
        int count_10=0;
        for(int i=0;i<bills.size();i++){
            if(bills[i]==5) count_5++;
            else if(bills[i]==10){
                if(count_5==0) return false;
                count_10++;
                count_5--;
            }else if(bills[i]==20){
                if((count_10<1 || count_5<1) && count_5<3) return false;
                if(count_10>0){
                    count_10--;
                    count_5--;
                }else{
                    count_5 -= 3;
                }
            }
        }
        return true;
    }
};

LeetCode406.根据身高重建队列

本题和分发糖果一题类似，都是不能同时兼顾两个维度，否则会顾此失彼，本题只能先确定身高维度，再确定排序维度。当身高按从高到低排之后（如果相同的身高，按排序维度从小到大，重要），那么根据每个人的排序，插入到对应的位置，则就是满足条件的排序组合。

代码如下，时间复杂度O(nlogn+n^2);空间复杂度O(n)

class Solution {
public:
    static bool cmp(vector<int> a,vector<int> b){
        if(a[0]==b[0]) return a[1]<b[1];
        return a[0]>b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort(people.begin(),people.end(),cmp);
        vector<vector<int>> que;
        for(int i=0;i<people.size();i++){
            que.insert(que.begin()+people[i][1],people[i]);
        }
        return que;
    }
};

但是以上是用vector效率非常低，因为底层是用数组实现，在每次添加的过程，当新数组的长度超过原先数组长度，则需要重新开辟一块与原先相比2倍的内存空间，然后将数据拷贝过去，非常费时，所以这里建议用链表实现，而list底层就是链表实现。卡哥代码如下：

class Solution {
public:
    // 身高从大到小排（身高相同k小的站前面）
    static bool cmp(const vector<int>& a, const vector<int>& b) {
        if (a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
        sort (people.begin(), people.end(), cmp);
        list<vector<int>> que; // list底层是链表实现，插入效率比vector高的多
        for (int i = 0; i < people.size(); i++) {
            int position = people[i][1]; // 插入到下标为position的位置
            std::list<vector<int>>::iterator it = que.begin();
            while (position--) { // 寻找在插入位置
                it++;
            }
            que.insert(it, people[i]);
        }
        return vector<vector<int>>(que.begin(), que.end());
    }
};

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

难点在于如何确定超过两个气球的交集是否可以一箭引爆，那么这里的思路很巧妙，可以通过不断直接修改处理气球的右区间，维护一个最小的值，那么下一个判断的气球只需和这个最小值比，如果左边界大于前面气球右边界的最小值，则需要result++,如果小于的话，说明这个气球可以和之前的气球一起引爆，result不需要++，思路巧妙！

代码如下：时间复杂度O(nlogn)快排；空间复杂度O(1)。

class Solution {
public:
    static bool cmp(vector<int> a,vector<int> b){
        return a[0]<b[0];
    }
    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(),points.end(),cmp);
        int result = 1;
        int right = 0;
        for(int i=1;i<points.size();i++){
            if(points[i][0]>points[i-1][1]){
                result++;
            }else{
                points[i][1] = min(points[i][1],points[i-1][1]);
            }
        }
        return result;
    }
};