第八章 贪心算法 part04（代码随想录）

860.柠檬水找零 

账单是20的情况，为什么要优先消耗一个10和一个5呢？

因为美元10只能给账单20找零，而美元5可以给账单10和账单20找零，美元5更万能！

• 情况一：账单是5，直接收下。
• 情况二：账单是10，消耗一个5，增加一个10
• 情况三：账单是20，优先消耗一个10和一个5，如果不够，再消耗三个5

局部最优：遇到账单20，优先消耗美元10，完成本次找零。

全局最优：完成全部账单的找零。

class Solution {
public:
    bool lemonadeChange(vector& bills) {
        // 5: 直接收
        // 10: 找零5, 如果没没5, return false
        // 20: 优先找10+5, 5+5+5
        int five = 0, ten = 0, twenty = 0;
        for (int bill : bills) {
            if (bill == 5) five++;
            if (bill == 10) {
                if (five <= 0) return false;
                ten++;
                five--;
            }
            if (bill == 20){
                // 优先消耗10美元，因为5美元的找零用处更大，能多留着就多留着
                if (five > 0 && ten > 0) {
                    five--;
                    ten--;
                    twenty++;
                } else if (five>=3){
                    five-=3;
                    twenty++;
                } else return false;
            } 
        }
        return true;
    }
};

 406.根据身高重建队列 

如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。

那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。

局部最优：优先按身高高的people的k来插入。插入操作过后的people满足队列属性

全局最优：最后都做完插入操作，整个队列满足题目队列属性

不能重新插入people，插入时已经改了people里面每个元素位置，遍历时很可能重复访问元素。

class Solution {
private:
    static bool cmp(const vector& a, const vector& b){
        if (a[0] == b[0]) return a[1] < b[1]; // 身高从大到小排（身高相同k小的站前面）
        return a[0] > b[0];
    }
public:
    vector> reconstructQueue(vector>& people) {
        // 按照身高(h)排序
        sort(people.begin(), people.end(), cmp);
        vector> que; // 放输出队列
        // 插入
        // 优先按身高高的people的k来插入，后序插入节点(身高一定小于前面)
        // 不会影响前面已经插入的节点，最终按照k的规则完成了队列。
        for (int i=0; i

[7,0] [7,1] [6,1] [5,0] [5,2] [4,4]

[7,0]

[7,0] [7,1]

[7,0] [6,1] [7,1]

[5,0] [7,0] [6,1] [7,1]

[5,0] [7,0] [5,2] [6,1] [7,1]

[5,0] [7,0] [5,2] [6,1] [4,4] [7,1]

 452. 用最少数量的箭引爆气球  （重叠区间）

局部最优：当气球出现重叠，一起射，所用弓箭最少。

全局最优：把所有气球射爆所用弓箭最少。

把气球排序之后，从前到后遍历气球，被射过的气球仅仅跳过就行了。

没必要让气球数组remove气球，只要记录一下箭的数量就可以了。

为了让气球尽可能的重叠，需要对数组进行排序。

按照左边界排序

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        if len(points) == 0: # 数组为0，弓箭数为0
            return 0
        points.sort(key=lambda x: x[0]) # 子数组第一个元素进行排序
        result = 1 # 数组不为0，一定至少一个
        for i in range(1, len(points)): #从1开始i和i-1进行比较
            # i个气球左边界>i-1个(气球右边界)=>2个气球一定不相邻，再需要一个弓箭
            if points[i][0] > points[i-1][1]:
                result+=1
            # 重叠的情况
            else:
                # 取2个气球最小右边界之后和下一个气球进行比较(本气球和上一个)
                # 更新右边界
                points[i][1]=min(points[i-1][1], points[i][1])
        return result