贪心算法——力扣455.分发饼干 ，376摆动序列，53最大子序和

以下将会有力扣上题目思路和与要注意的内容的详细讲解，并附上正确代码。

知识漏洞：

向量排序函数

vector<int> vec{1,2,3,4};

//默认从小到大排序  1234
sort(vec.begin(),vec.end());
//从大到小排序 4321
sort(vec.begin(),vec.end(),greater<int>());

 

力扣题目

一.  力扣455.分发饼干 

1.思路：

就是最简单的贪心方法，分别将胃口值和饼干尺寸从大到小进行排序，一一对应进行比较，如果胃口值小于等于饼干尺寸则分配，反之对下一个孩子的胃口与当前饼干进行匹配。

2.代码如下：

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end(),greater<int>());
        sort(s.begin(),s.end(),greater<int>());
        int i = 0,j = 0,con = 0;
        while(i < g.size() && j < s.size())
        {
            if(g[i]<=s[j])
            {
                con++;
                i++;
                j++;
            }
            else
            {
                i++;
            }
        }
        return con;
    }
};

 

二. 376摆动序列

1.思路

这道题我们要知道我们想要的序列是这样的，如图所示：

这种增减更替的，代码中我们用con记录可以纳入摆动序列的元素的个数，如果遇到如下图所示的持续增或减，那么我们把最大值和最小值也就是结点处的元素纳入摆动序列之中。

如图所示，一目了然：

2.代码完成

这里我用next来确定我们需要的下一个元素应大于上一个元素还是小于上一个元素。

循环判断时也是根据next的值和当前元素与上一个元素的大小关系是否满足条件来判断的。

代码如下：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int s = nums.size();

        //分别对向量长度为一和向量长度为零的情况进行处理
        if(s == 0)
            return 0;
        if(s==1)
            return 1;

        //向量长度大于1时
        int con = 1;
        int next;//下一个差值需要是正数则next为1，需要为负则next为0
        int p = 0,q = 1;
        while(nums[q] == nums[p] && q<s-1)
        {
            q++;
            p++;
        }
        if(nums[q]>nums[p])
        {
            next = 0;
            con++;
        }
        if(nums[q]<nums[p])
        {
            next = 1;
            con++;
        }
        for(int i = q+1;i < nums.size();i++)
        {
            if(next == 1 && nums[i]>nums[i-1])
            {
                con++;
                next = 0;
            }
            if(next == 0 && nums[i]<nums[i-1])
            {
                con++;
                next = 1;
            }
        }
        return con;
    }
};

3.需要注意的点：

初始化next时需要考虑p和q的初始化，还要考虑元素数字相等的情况，所以我设置了循环。

三.53最大子数组和

1.思路

当当前子数组和是一个负数时，把这个负数看作是起点，那么只会使后边的数组和更小，所以这个时候就要放弃之前的子数组，使下一个元素作为起点重新开始。

同时在遍历的过程中我么要注意时刻更新最终结果，也就是最大数组和。

2.易错点

这是我一开始写的代码

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int con = 0;
        int r = INT32_MIN;//最大子数组和
        for(int i = 0;i < nums.size();i++)
        {
            con += nums[i];
            if(con < 0)
                con = 0;
            if(r < con)
                r = con;
        }
        return r;
    }
};

发现全是负数的时候跑不过，r会被更新为0，还不知道怎么改，其实只需要把两个if语句调换一下就好了，这样就可以找到最小的那个负数，就是最终结果。

还有就是要注意r要初始化为最小负数而不是0.

3.代码

思路会了代码so easy，一两分钟就能完成。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int con = 0;
        int r = INT32_MIN;//最大子数组和
        for(int i = 0;i < nums.size();i++)
        {
            con += nums[i];
            if(r < con)
                r = con;
            if(con < 0)
                con = 0;
        }
        return r;
    }
};