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

LeetCode 455 分发饼干

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

思路：

自己的想法：

先将胃口和饼干快排好。然后用两个for循环，一个遍历胃口，一个遍历饼干。第一个for循环是胃口，第二个for循环是饼干。找到可以喂饱当前胃口的饼干，记录下来它的index；然后到下一个小孩的胃口此时饼干遍历从index+1开始，因为前面的明显不满足条件。类似于小饼干先喂饱小胃口，代码方面写的复杂了。

代码：

• 自己的

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

• 小饼干先喂饱小胃口

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int index = 0;
        // 小饼干先喂饱小胃口
        for(int i = 0;i<s.size();i++)
        {
            if(index<g.size()&&g[index]<=s[i])
                index++;
        }
        return index;
    }
};

总结

思路相对简单，但是自己写代码的时候写复杂了。

LeetCode 376 摆动序列

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

思路：

一开始想着用回溯，结果发现太复杂了，根本做不出来。直接看卡哥讲解，非常清晰。

代码：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()==1)  return nums.size();
        int prediff = 0;    // 默认左边有个平坡，即nums[0]->num[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;  // 放在if里面是防止出现单调坡上有平坡的情况
            }
        }
        return result;
    }
};

总结

根本没想到，寄。

LeetCode 53 最大子序和

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

思路：

如果是[-2,1]在一起，计算起点的时候，一定是从1开始计算，因为负数只会拉低总和，这就是贪心贪的地方！即如果连续和是负数，立刻舍弃，从下一个数开始重新计算连续和。

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

全局最优：选取最大“连续和”

代码：

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];
            result = count>result?count:result; // 更新最大值
            if(count<0) count = 0;  // 如果连续和为负数，那么就将连续和变成下一个nums里的数。即count = nums[i+1]，令其为0即可。
        }
        return result;
    }
};

总结

多练习，记一记。

今日总结：

只能写出第一题，其余两题都没有什么思路，不知道应该贪心贪在哪里，要多加练习。