【代码随想录|贪心算法01】

代码随想录贪心算法文章链接代码随想录

理论：贪心本质是局部最优推出全局最优

and 贪心没有套路练就完事了

455.分发饼干

题目链接https://leetcode.cn/problems/assign-cookies

思路：尽量用大的饼干喂给胃口大的小孩

胃口：1,3,7,10

饼干：1,3,5,9

我们先把胃口数组和小孩数组进行排序，遍历胃口数组，我们把胃口数组从后往前遍历，只要我饼干数组能喂的就给，index--;小孩数count++，如果喂不了我就继续i--往前面找找胃口小的小孩。

这里只能用遍历胃口的数组来进行比较，因为如果从后往前遍历饼干数，我最大的饼干9拿去比发现要10，进行下次循环是饼干往前，那9给不了我1 3 5肯定也给不了。因此这里只能遍历胃口数组

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(s.begin(), s.end());//饼干数组
        sort(g.begin(), g.end());//胃口数组
        int index = s.size() - 1;//指向饼干数组的下标
        int count = 0;//计数能喂给小孩的数量
        for (int i = g.size() - 1; i >= 0; i--) {//遍历胃口是i>=0因为从(0,size-1)都要比较
            while (index > 0 && s[index] >= g[i]) {//遍历饼干
                index--;
                count++;
            }
        }
        return count;
    }
};

376.摆动序列

题目链接https://leetcode.cn/problems/wiggle-subsequence

我们主要要删除的点是坡度上的点，对有坡度的点进行计数

局部最优：删除坡度上的点

整体最优：有最长的摆动序列

这里的思路是我遍历整个数组，每一轮都算出数组中下一个值和这个值的差curdiff和这个值和数组上一个值的差prediff(这里prediff不用每轮都算，只要坡度变化了我再把prediff的值赋值为curdiff)坡度变化，那计数摆动序列值加加

有二种情况

 一、上下坡中有平坡

比如[1,2,2,2,1]的序列

可以整体删掉平坡的左边数，只计数一个

所以我左边坡度prediff == 0，右边坡度无论是上升还是下降我都把这个把这个值计数
二、数组首尾两端              

当传入的数组只有两个数的时候题目说是算2的，那为了把这种情况和条件中结合起来，就把result计数为1，把最后一个值看成一个坡，如果传入的是两个值[2,3]，你的prediff初始为0，所以2这个点也会进行计数，算出来的result为2

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1)
            return nums.size();
        int prediff = 0;//前一坡度
        int curdiff = 0;//现在这一坡度
        int result = 1;
        for (int i = 0; i < nums.size() - 1; i++) {
            curdiff = nums[i + 1] - nums[i];
           
            if ((prediff <= 0 && curdiff > 0) ||
                (prediff >= 0 && curdiff < 0)) {
                result++;
                prediff=curdiff;//坡度变化后再赋值
            }
            
        }
        return result;
    }
};

53.最大子数组和

题目链接https://leetcode.cn/problems/maximum-subarray

局部最优：连续和已经为负数后就放弃这个值，因为负数只会越加越小。

整体最优：有最大的连续子数组和

思路感觉就是如果我现在相加的值已经为负数了，那就直接把现在存的连续和count赋值为0吧，从新再看看后面的数能不能比result更大（也就是都是负数的话，选个最大的负数就得了，你再加的话越加越小没必要hhh），这道题颇有种哲学意义呀，过去的就让他过去吧，我们从零开始。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result=INT_MIN;
        int count=0;
        for(int i=0;i<nums.size();i++){
            count+=nums[i];
            if(count>result)result=count;//只有大于前一个存的最大和再赋值
            if(count<0)count=0;//重新赋值
        }
        return result;
    }
};