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

#860 柠檬水找零 easy, 常识：找零先找大额的，因为小额的钱更万能。随想录思路一样

bool lemonadeChange(vector<int>& bills) {
        map<int,int> money;

        for(int i=0;i<bills.size();i++){
            if(bills[i]==5) money[5]++;
            else if(bills[i]==10){
                if(money[5]==0) return false;
                money[10]++;
                money[5]--;
            }
            else if(bills[i]==20){
                money[20]++;
                if(money[10]>=1) {
                    money[10]--;
                    if(money[5]==0) return false;
                    money[5]--;
                }
                else if(money[5]>=3) money[5]-=3;
                else return false; 
            }

        }
        return true;
    }

#406.根据身高重建队列

看的思路自己写的

思路：遇到两个维度权衡的时候，一定要先确定一个维度，再确定另一个维度； 两个维度一起考虑一定会顾此失彼

如果按照k来从小到大排序，排完之后，会发现k的排列并不符合条件，身高也不符合条件，两个维度哪一个都没确定下来。那么按照身高h来排序呢，身高一定是从大到小排（身高相同的话则k小的站前面），让高个子在前面。

code：sort自定义cmp函数写起来很不熟练，要加强。

vec是可以用insert(pos, ele) 插入任意位置的，但是时间复杂度比较高，底层逻辑还是一个个找过来的

    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) {
        
        vector<vector<int>> res;
        sort(people.begin(),people.end(),cmp);

        for(int i=0;i<people.size();i++){
            res.insert(res.begin() + people[i][1], people[i]);
        }
        return res;
        
    }

我初看此题看到要不断插入，其实觉得最合适的数据结构是链表，于是又用list写了一下。

但是发现并没有快，时间复杂度是一样的

    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {
  
        list<vector<int>> res;
        sort(people.begin(), people.end(), cmp);

        for(const auto& p : people){
            auto it = res.begin();
            std::advance(it, p[1]);
            res.insert(it, p);
        }
        return vector<vector<int>>(res.begin(), res.end());
        
    }

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

25min,思路出来很快，都是在修复小bug

我的code：

1.画个图思路会非常明了，就是不断找overlap area，并做更新；一开始

我一开始在have overlap那里更新的不对，只考虑到了错开，没考虑到包含。但一般更新overlap都是，新开头选大的，新结尾选小的（常识啊！）

2. 排序那里其实不用管end，只按照start排序就行

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];
    }

    int findMinArrowShots(vector<vector<int>>& points) {
        sort(points.begin(),points.end(),cmp);
        for(auto &ele:points){printf("[%d,%d] ",ele[0],ele[1]);}
        cout<<endl;
        int cnt=0;
        int old_start=0;
        int old_end=0;

        for(int i=0;i<points.size();i++){
            if(old_end<points[i][0] || i==0){//no overlap
                cnt++;
                old_start=points[i][0];
                old_end=points[i][1];
            }
            else{ //have overlap
                old_start=std::max(points[i][0],old_start);
                old_end= std::min(points[i][1],old_end);
            }
            printf("after update: (%d,%d)\n",old_start,old_end);
        }
        return cnt;
        
    }

随想录不是用old标记，是用i和i-1，其实没什么差别：

static bool cmp(const vector<int>& a, const vector<int>& b) {
        return a[0] < b[0];
    }
public:
    int findMinArrowShots(vector<vector<int>>& points) {
        if (points.size() == 0) return 0;
        sort(points.begin(), points.end(), cmp);

        int result = 1; // points 不为空至少需要一支箭
        for (int i = 1; i < points.size(); i++) {
            if (points[i][0] > points[i - 1][1]) {  // 气球i和气球i-1不挨着，注意这里不是>=
                result++; // 需要一支箭
            }
            else {  // 气球i和气球i-1挨着
                points[i][1] = min(points[i - 1][1], points[i][1]); // 更新重叠气球最小右边界
            }
        }
        return result;
    }