代码随想录算法训练营第二十四天| 455.分发饼干, 376. 摆动序列 , 53. 最大子序和

今天是贪心算法学习的第一天，主要的学习内容有：贪心算法的理论基础，以及如何通过局部最优解推导全局最优解。

对于贪心的理论基础，贪心算法并没有固定的模板和套路，对于贪心算法的题目其实就是一种模拟题，需要找到一个局部最优的解法，并尝试通过局部最优的方法得到全局最优解。实际做题下来感觉贪心算法就是考察一些trick的题目，很多题目需要去有一些比较好的思维才可以做出来。

455.分发饼干

题目链接：455. 分发饼干 - 力扣（LeetCode）

这个题目有两种思路，一种是把小块的饼干优先满足胃口小的孩子，另一种是把大块的饼干优先满足胃口大的孩子。两种做法都是可以的。具体代码实现如下：
 

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int num=0;
        vector<bool> used(s.size(),false);
        if(s.size()==0) return 0;
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int j=0;
        for(int i=0;i<g.size();i++)
        {
            while(j<s.size()&&s[j]<g[i]) j++;
            if(j<s.size()&&s[j]>=g[i]&&used[j]==0)
            {
                used[j]=1;
                num++;
                j++;
            }
        }
        return num;
    }
};

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int j=s.size()-1;
        if(j<0) return 0;
        int num=0;
        for(int i=g.size()-1;i>=0;i--)
        {
            if(s[j]>=g[i]&&j>=0)
            {
                num++;
                if(j==0) break;
                if(j>0) j--;
            }
        }
        return num;
    }
};

376. 摆动序列 

题目链接：376. 摆动序列 - 力扣（LeetCode）

这个题目就比较难了，要找到摆动序列，大致思路是找波峰和波谷，基于这种思路，需要考虑下面三种情况：

1.上下坡有平坡。我们使用prediff用于记录num[i]-num[i-1]，curdiff用于记录nums[i+1]-num[i]，在有平坡的情况下，prediff=0&&curdiff>0和prediff=0&&curdiff<0都是可以满足计数条件的。综上所述，我们的判别条件是prediff<=0&&curdiff>0和prediff>=0&&curdiff<0.

2.数组首尾两端。对于数组首段，我们可以将prediff初始化为0，这样就可以对第一个数进行计数。对于数组尾端，我们默认最右边有一个峰值，result初始化为1.

3.单调坡度有平坡。如下图所示

如果按照我们的算法进行求解，会得到的结果为3，为解决这一情况，我们对prediff的更新当且仅当存在坡度差的时候，这样的话图中的2就不会被认定为一个波峰。

具体代码实现如下所示：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        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. 最大子序和 

题目链接：53. 最大子数组和 - 力扣（LeetCode）

这个题目要求找到一个数组中求和结果最大的连续子序列。我的第一想法就是用动态规划来做。感觉比贪心更直观好理解。具体代码实现如下：
 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> dp(nums.size()+5,-10010);
        if(nums.size()==0) return 0;
        dp[0]=nums[0];
        for(int i=1;i<nums.size();i++)
        {
            dp[i]=max(dp[i-1]+nums[i],nums[i]);
        }
        int max=-10010;
        for(int i=0;i<dp.size();i++)
        {
            if(dp[i]>max) max=dp[i];
        }
        return max;
    }
};

后来参考了随想录的题解，做法是进行累加操作，如果和为负数就更新为0，为正数就继续累加，并且每一次循环都会更新最大值。具体代码实现如下：
 

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int count=0;
        int result=-10010;
        for(int i=0;i<nums.size();i++)
        {
            count+=nums[i];
            if(count>result)
            {
                result=count;
            }
            if(count<=0) count=0;
        }
        return result;
    }
};