代码随想录一刷心得之贪心算法篇

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

解题方法：常识性推导加上举反例

买卖股票的最佳时机II

//从前往后遍历右孩大于左孩，再从后往前左孩大于右孩

class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyVec(ratings.size(),1);
        for(int i=1;i<ratings.size();i++){
            if(ratings[i]>ratings[i-1])candyVec[i]=candyVec[i-1]+1;
//从前往后遍历右孩大于左孩，再从后往前左孩大于右孩
        }
        for(int i=ratings.size()-2;i>=0;i--){
            if(ratings[i]>ratings[i+1]){
                candyVec[i]=max(candyVec[i],candyVec[i+1]+1);
            }//取二者最大值是又是一个局部最优的贪心算法
        }
        int result=0;
        for(int i=0;i<candyVec.size();i++)result+=candyVec[i];
        return result;
    }
};

```cpp
class Solution {
public:
    int candy(vector<int>& ratings) {
        vector<int> candyVec(ratings.size(),1);
        for(int i=1;i<ratings.size();i++){
            if(ratings[i]>ratings[i-1])candyVec[i]=candyVec[i-1]+1;
//从前往后遍历右孩大于左孩，再从后往前左孩大于右孩
        }
        for(int i=ratings.size()-2;i>=0;i--){
            if(ratings[i]>ratings[i+1]){
                candyVec[i]=max(candyVec[i],candyVec[i+1]+1);
            }//取二者最大值是又是一个局部最优的贪心算法
        }
        int result=0;
        for(int i=0;i<candyVec.size();i++)result+=candyVec[i];
        return result;
    }
};

柠檬水找零要一张张考虑

class Solution {
public:
    bool lemonadeChange(vector<int>& bills) {
        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){
                if(five>0&&ten>0){
                    five--;
                    ten--;
                    twenty++;
                }else if(five>=3){
                    five-=3;
                    twenty++;
                }else return false;
            }
        }
        return true;
    }
};

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

class Solution {
public:
    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);//按高度排，若高度相等则按k排
        vector<vector<int>> que;
        for(int i=0;i<people.size();i++){
            int position=people[i][1];
            que.insert(que.begin()+position,people[i]);
        }
        return que;
    }
};

链表写法，用迭代器

class Solution {
public:
    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);//按高度排，若高度相等则按k排
        list<vector<int>> que;
        for(int i=0;i<people.size();i++){
            int position=people[i][1];
            std::list<vector<int>>::iterator it = que.begin();
            while(position--){
                it++;
            }
            que.insert(it,people[i]);
        }
        return vector<vector<int>>(que.begin(),que.end());
    }
};

vector当insert数据的时候，如果已经大于capicity，capicity会成倍扩容，但对外暴漏的size其实仅仅是+1。

无重叠区间跟划分字母区间很类似，甚至代码可以复用

划分字母区间——要点：转化成数字的比较

stoi函数. 作用是将 n 进制的字符串转化为十进制

return stoi(strNum)

买卖股票的最佳时机含手续费

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int result;
        int minPrice = prices[0];
        for(int i=1; i < prices.size(); i++){
            if(prices[i] < minPrice) minPrice = prices[i];
            if(prices[i] >= minPrice && prices[i] <= minPrice + fee){
                continue;
            }//可以删掉
            if(prices[i] > minPrice + fee){
                result += prices[i] - minPrice - fee;
                minPrice = prices[i] - fee;//收获利润的这一天并不是收获利润区间里的最后一天（不是真正的卖出，相当于持有股票），所以后面要继续收获利润，比如8块钱卖出后，后面还有11块钱的，可以再买入8块的后面再卖。
            }
        }
        return result;
    }
};

监控二叉树（要注意二叉树三种情况以及空节点的判定）

• 0：该节点无覆盖
• 1：本节点有摄像头
• 2：本节点有覆盖