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

me_llamo

于 2024-07-29 14:37:16 发布

阅读量231

点赞数 7

文章标签：算法

本文链接：https://blog.csdn.net/weixin_45182267/article/details/140763679

版权

碎碎念：开始贪心！
参考：代码随想录

贪心算法理论基础

贪心算法的本质： 找到每个阶段的局部最优，从而去推导全局最优。
我们要想清楚每个阶段的局部最优解是什么，这个局部最优能不能推出全局最优。

455.分发饼干

题目链接

455.分发饼干

思想

局部最优就是尽量用大饼干喂胃口大的小孩，推出全局最优就是能满足的小孩数量最多。我们找不出明显的反例来否决这个假设，所以我们用贪心来试试。
首先要将胃口数组和饼干大小数组进行排序。
定义一个变量result来记录满足的小孩个数。定义一个index从size-1开始，方便遍历饼干的大小.
孩子胃口的从大到小遍历，如果index>=0且饼干的大小大于小孩的胃口，result++，index–。
最后返回result即可。

题解

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

# python
class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        g.sort()
        s.sort()
        result = 0
        index = len(s) - 1
        for i in range(len(g)-1, -1, -1):
            if index >= 0 and s[index] >= g[i]:
                result += 1
                index -= 1
        return result

反思

不能外面的for循环控制饼干大小，里面控制孩子的胃口大小。
也可以尽量用小饼干去满足小孩，充分利用小饼干。

376. 摆动序列

题目链接

376. 摆动序列

思想

局部最优： 删掉单调坡里的元素
全局最优： 得到了最长的摆动序列
明确摆动的条件，遇到坡度不++，遇到摆动就++，不需要真的去做删除。
如何判断摆动：
比如当前遍历到i，求prediff=nums[i] - nums[i-1]，curdiff=nums[i+1]-nums[i]，如果prediff>=0且curdiff<0或者prediff<=0且curdiff>0，就说明遇到摆动了。

数组可能的几种情况：

上下坡有平坡
选定一个方向删除，本解法是删除了左边的平坡元素，保留了最右边的，体现在代码里就是判断prediff时有等于号。
首尾元素
处理首元素，向前延伸一个平坡。体现在代码里就是prediff初始值为0.
处理尾元素，是一只有一个摆动的，所以result初始为1，也就是从一开始就加上了这个摆动。

这样整个数组只有两个元素的时候也可以正常去遍历。
3. 单调有平坡
prediff只记录当摆动出现的时候下一坡的初始的坡度，直到下次又改变坡度方向才修改prediff，体现在代码里，就是prediff=curdiff写在if的逻辑里。
在这里插入图片描述

题解

// cpp
class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        int curDiff = 0;
        int preDiff = 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;
    }
};

# python
class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums) <= 1:
            return len(nums) 
        curDiff = 0
        preDiff = 0
        result = 1
        for i in range(len(nums) - 1):
            curDiff = nums[i + 1] - nums[i]
            if (preDiff <= 0 and curDiff > 0) or (preDiff >= 0 and curDiff < 0):
                result += 1
                preDiff = curDiff
        
        return result

反思

注意要把所有情况都分清楚。

53. 最大子序和

题目链接

53. 最大子序和

思想

遍历数组的时候累加连续和，如果累加出来一个负数，一定会把后面的数越加越小，那么我们最好找后面的数字连续和新的起点。
局部最优： 当求到连续和为负数的时候立刻抛弃它，因为负数总会拖累我们的综合。
全局最优： 找到最大连续子序和。
我们找不出反例，所以按照贪心的思路试一下。
只要连续和不为负数的时候就继续往后加。
定义一个result初始化为INT_MIN，count=0；
for循环，遍历nums中的每一个元素，累加nums[i]到count，如果count>result，更新result，如果count是负数，count=0；
返回result。

题解

// cpp
class 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;
    }
};

# python
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        result = float('-inf')
        count = 0
        for i in range(len(nums)):
            count += nums[i]
            if count > result:
                result = count
            if count <= 0:
                count = 0
        return result