代码随想录|day31|贪心算法part01----● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和

贪心算法其实就是没有什么规律可言，所以大家了解贪心算法 就了解它没有规律的本质就够了。

不用花心思去研究其规律， 没有思路就立刻看题解。

基本贪心的题目 有两个极端，要不就是特简单，要不就是死活想不出来。

学完贪心之后再去看动态规划，就会了解贪心和动规的区别。

455.分发饼干

链接：代码随想录

 

思路：简单的给小饼干排序，给小朋友胃口排序，然后对于每块小饼干，如果小孩子吃了，下一次循环就看下一块小饼干和这个孩子之后的孩子。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int n=g.size();//n个孩子
        int m=s.size();//m块小饼干
        if(m==0)
        {
            return 0;
        }
        sort(s.begin(),s.end());
        sort(g.begin(),g.end());
        int j=0;//孩子序列的指针
        int cnt=0;
        for(int i=0;i<m;i++)//饼干序列的指针
        {
            if(j<n &&  s[i]>=g[j])
            {
                cnt++;
                j++;
            }
        }
        return cnt;


    }
};

 

376. 摆动序列 

链接：代码随想录

 

个人觉得代码随想录的答案太不容易想了，容易出错。所以这里我想出来一种

class Solution {
public:
/*先把相差的数列求出来，得到差值序列，其中如果插值为0直接省略
*/
    int wiggleMaxLength(vector<int>& nums) {
        int n=nums.size();
        if(n==1)
        {
            return 1;
        }
        vector<int>v;//差值数组
        for(int i=1;i<n;i++)
        {
            int temp=nums[i]-nums[i-1];
            if(temp<0)
            {
                v.push_back(-1);
            }
            else if(temp>0)
            {
               v.push_back(1);
            }
            else//是0的话无视，因为没有意义
            {

            }
        }
        if(v.size()==0)//所有差值均为0
        {
            return 1;
        }
        if(v.size()==1)//[1,2]这种情况
        {
            return 2;
        }
        //比如1 1 -1 -1  实质上只有1 -1,所以这一步要做的是所有相同符号的合并
        int cnt=0;
        for(int i=1;i<v.size();i++)
        {
            if(v[i]!=v[i-1])//出现波动
            {
               cnt++;
            }
        }
        return cnt+2;
       
      
    }
};

53. 最大子序和 

链接：代码随想录

 

动态规划思路：

class Solution {
public:
//连续子数组，并不是子序列
/*想用动态规划做。dp[i-1]是以nums[i-1]为结尾的最大子数组和，dp[i]=max(dp[i-1],dp[i-1]+nums[i])

dp[i-1]<0,nums[i]>0, dp[i]=nums[i]
dp[i-1]<0,nums[i]<0,dp[i]=nums[i]
dp[i-1]>0,nums[i]>0,dp[i]=dp[i-1]+nums[i]
dp[i-1]>0,nums[i]<0,dp[i]=dp[i-1]+nums[i]
总结：dp[i-1]<0,dp[i]=nums[i]
      dp[i-1]>0，dp[i]=dp[i-1]+nums[i]

*/

    int maxSubArray(vector<int>& nums) {
        int n=nums.size();
        if(n==1)
        {
            return nums[0];
        }
        vector<int>dp(n,0);
        dp[0]=nums[0];
        int maxx=nums[0];
        for(int i=1;i<n;i++ )
        {
            if(dp[i-1]<=0)
            {
               dp[i]=nums[i]; 
            }
            else
            {
               dp[i]=dp[i-1]+nums[i];
            }
            maxx=max(maxx,dp[i]);
        }

        return maxx;
    }
};

 贪心思路

从代码角度上来讲：遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。（为什么不再用前面的？如若前面的已经是负数，则不如从头开始）

这个代码总是写不对，由于更新最大值的位置在最中间。

Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT32_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;
    }
};