代码随想录打卡Day35 | 贪心算法 part04

心得：

第一题、比较简单，就在遇到20美元时。优先消耗10美元的即可。

第二题、先根据身高排序，再根据位置进行插入，两次贪心。

第三题、也是两次贪心，先用左区间排序，再遍历时用右区间判断是否冲的，一直更新最小的右区间。

---

---

第一题、柠檬水找零 LeetCode860  https://leetcode.cn/problems/lemonade-change/

在柠檬水摊上，每一杯柠檬水的售价为 5 美元。顾客排队购买你的产品，（按账单 bills 支付的顺序）一次购买一杯。

每位顾客只买一杯柠檬水，然后向你付 5 美元、10 美元或 20 美元。你必须给每个顾客正确找零，也就是说净交易是每位顾客向你支付 5 美元。

注意，一开始你手头没有任何零钱。

给你一个整数数组 bills ，其中 bills[i] 是第 i 位顾客付的账。如果你能给每位顾客正确找零，返回 true ，否则返回 false 。

不用想那么复杂， 收到5就5++，10就10++，5--，20就优先10--5--，再5减三个。

class Solution {
public:
    bool lemonadeChange(vector& bills) {
        int five = 0;
        int ten = 0;
        for(int i = 0; i < bills.size(); i++){
            if(bills[i] == 5){
                five++;
            }
            if(bills[i] == 10){
                ten++;
                five--;
            }
            if(bills[i] == 20){
                if(ten > 0){//优先消耗10美元
                    ten--;
                    five--;
                }
                else {
                    five -= 3;
                }
                
            }
            if(five < 0 || ten < 0) return false;
        }
        return true;
    }
};

 

---

---

第二题，根据身高体重建队列 LeetCode406 https://leetcode.cn/problems/queue-reconstruction-by-height/

 

假设有打乱顺序的一群人站成一个队列，数组 people 表示队列中一些人的属性（不一定按顺序）。每个 people[i] = [hi, ki] 表示第 i 个人的身高为 hi ，前面 正好 有 ki 个身高大于或等于 hi 的人。

请你重新构造并返回输入数组 people 所表示的队列。返回的队列应该格式化为数组 queue ，其中 queue[j] = [hj, kj] 是队列中第 j 个人的属性（queue[0] 是排在队列前面的人）。

 

如果两个维度一起考虑一定会顾此失彼。

对于本题相信大家困惑的点是先确定k还是先确定h呢，也就是究竟先按h排序呢，还是先按照k排序呢？

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

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

此时我们可以确定一个维度了，就是身高，前面的节点一定都比本节点高！

那么只需要按照k为下标重新插入队列就可以了，为什么呢？

以图中{5,2} 为例：

按照身高排序之后，优先按身高高的people的k来插入，后序插入节点也不会影响前面已经插入的节点，最终按照k的规则完成了队列。

所以在按照身高从大到小排序后：

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

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

局部最优可推出全局最优，找不出反例，那就试试贪心。

使用vector解题：

class Solution {
public:
    static bool cmp(const vector& a, const vector& b){
        if(a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    
    vector> reconstructQueue(vector>& people) {
        sort(people.begin(), people.end(), cmp);
        vector> que; 
        list> que;
        for(int i = 0; i < people.size(); i++){
            int position = people[i][1];
            que.insert(que.begin() + position, people[i]);// 插入到下标为position的位置
        }
        return que;
    }
};

 

但使用vector是非常费时的，C++中vector（可以理解是一个动态数组，底层是普通数组实现的）如果插入元素大于预先普通数组大小，vector底部会有一个扩容的操作，即申请两倍于原先普通数组的大小，然后把数据拷贝到另一个更大的数组上。

所以使用vector（动态数组）来insert，是费时的，插入再拷贝的话，单纯一个插入的操作就是O(n^2)了，甚至可能拷贝好几次，就不止O(n^2)了。

改成链表之后使用list容器：

class Solution {
public:
    static bool cmp(const vector& a, const vector& b){
        if(a[0] == b[0]) return a[1] < b[1];
        return a[0] > b[0];
    }
    
    vector> reconstructQueue(vector>& people) {
        sort(people.begin(), people.end(), cmp);
        //vector> que; 
        list> que;
        for(int i = 0; i < people.size(); i++){
            int position = people[i][1];
            //que.insert(que.begin() + position, people[i]);// 插入到下标为position的位置
            std::list>::iterator it = que.begin();
            while(position--){
                it++;
            }
            que.insert(it,people[i]);
        }
        return vector>(que.begin(), que.end());
    }
};

---

---

第三题、用最少数量的箭引爆气球 LeetCode452 https://leetcode.cn/problems/minimum-number-of-arrows-to-burst-balloons/

 

有一些球形气球贴在一堵用 XY 平面表示的墙面上。墙面上的气球记录在整数数组 points ，其中points[i] = [xstart, xend] 表示水平直径在 xstart 和 xend之间的气球。你不知道气球的确切 y 坐标。

一支弓箭可以沿着 x 轴从不同点 完全垂直 地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend， 且满足  xstart ≤ x ≤ xend，则该气球会被 引爆 。可以射出的弓箭的数量 没有限制 。 弓箭一旦被射出之后，可以无限地前进。

给你一个数组 points ，返回引爆所有气球所必须射出的 最小 弓箭数 。

同样是有左右区间需要处理，可以先按照左侧区间排序，然后在遍历的时候用右侧区间来确定需不需要多的箭。

如果气球重叠了，重叠气球中右边边界的最小值 之前的区间一定需要一个弓箭。

以题目示例： [[10,16],[2,8],[1,6],[7,12]]为例，如图：（方便起见，已经排序）

可以看出首先第一组重叠气球，一定是需要一个箭，气球3，的左边界大于了 第一组重叠气球的最小右边界，所以再需要一支箭来射气球3了。

 

class Solution {
public:
    static bool cmp(const vector& a, const vector& b){
        return a[0] < b[0];
    }

    int findMinArrowShots(vector>& points) {
        if(points.size() == 0) return 0;
        sort(points.begin(), points.end(), cmp);

        int res = 1;//从1开始
        for(int i = 1; i < points.size(); i++){
            if(points[i][0] > points[i - 1][1]){
                res++;
            }
            else{//左边界大于上一个的右边界
                points[i][1] = min(points[i - 1][0], points[1][0]);//更新最小右边界
            }
        }
        return res;
    }
};