代码随想录算法训练营第二十七天（贪心一）-CSDN博客

本文链接：https://blog.csdn.net/b1ankwall/article/details/141571936

硬拖拖到现在才写完。。。

关于贪心:

文章链接: 代码随想录

文章摘要:

贪心的本质是选择每一阶段的局部最优，从而达到全局最优。

贪心算法并没有固定的套路。

和其他算法不同，贪心没有能看出局部最优是否能推出整体最优的通法。

用来验证可不可以用贪心算法的最好策略就是举反例，如果想不到反例，那么就试一试贪心吧。

面试中基本不会让面试者现场证明贪心的合理性，代码写出来跑过测试用例即可，或者自己能自圆其说理由就行了。

很多同学通过（accept）了贪心的题目，但都不知道自己用了贪心算法，因为贪心有时候就是常识性的推导，所以会认为本应该就这么做！

看起来这算法挺玄乎，那么来几道题感受感受吧！

力扣题:

455.分发饼干

题目链接: . - 力扣（LeetCode）

题面:

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

思路:

一下子没想出来，看完觉得其实挺简单的：

为了满足更多的小孩，就不要造成饼干尺寸的浪费。

大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。

看到这里相信有点思路了吧?

局部最优：大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个

全局最优：喂饱尽可能多的小孩。

先将饼干数组和小孩数组排序，然后用大饼干优先满足胃口大的，并统计满足小孩数量。

用两个下标表示读取饼干和小孩数组的顺序，如果排序从低到高，那就两个下标就从末尾开始读取，从后往前，饼干肯定足够大，孩子胃口也足够大，如果孩子能满足的话就吃下足够大的饼干,此时计数器计数并往下走，如果孩子胃口满足不了，就去往下找能满足胃口的孩子。

这么说可能有点绕，看代码其实还一目了然一些。

代码实现:

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(),g.end());
        sort(s.begin(),s.end());
        int count = 0, si = s.size() - 1, gi = g.size() - 1;
        while(si >= 0 && gi >= 0)
        {
            if(g[gi] <= s[si]) si --, gi --, count ++;
            else gi --;
        }
        return count;
    }
};

376. 摆动序列

题目链接:. - 力扣（LeetCode）

题面:

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。
相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。

子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

思路:

本题要求通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

相信这么一说吓退不少人，这要求最大摆动序列又可以修改数组，这得如何修改呢？

来分析一下，要求删除元素使其达到最大摆动序列，应该删除什么元素呢？

用示例二来举例，如图所示：

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

局部最优推出全局最优，并举不出反例，那么试试贪心！

（为方便表述，以下说的峰值都是指局部峰值）

实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）

这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点

在计算是否有峰值的时候，大家知道遍历的下标 i ，计算 prediff（nums[i] - nums[i-1]）和 curdiff（nums[i+1] - nums[i]），如果prediff < 0 && curdiff > 0 或者 prediff > 0 && curdiff < 0 此时就有波动就需要统计。

这是我们思考本题的一个大体思路，但本题要考虑到相连的元素相等的情况（也就是平坡），

平坡分两种，一个是上下中间有平坡，一个是单调有平坡，如图：

下面的部分代码有一个值得好好讲的东西：

为什么preDiff = curDiff会在if条件里面呢？按常理来讲preDiff应该实时更新才对，但是如果实时更新下面的图就会得到错误的答案：

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; // 注意这里，只在摆动变化的时候更新prediff
            }
        }

图中，我们可以看出，版本一的代码在三个地方记录峰值，但其实结果因为是 2，因为单调中的平坡不能算峰值（即摆动）。

另一种当然就是下中间有平坡了，如图：

在图中，当 i 指向第一个 2 的时候，prediff > 0 && curdiff = 0 ，当 i 指向最后一个 2 的时候 prediff = 0 && curdiff < 0。

如果我们采用，删左面三个 2 的规则，那么当 prediff = 0 && curdiff < 0 也要记录一个峰值，因为他是把之前相同的元素都删掉留下的峰值。

所以我们记录峰值的条件应该是： (preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)，为什么这里允许 prediff == 0 ，就是为了上面我说的这种情况

其实本题看起来好像简单，但需要考虑的情况还是很复杂的，而且很难一次性想到位。

代码实现:

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; // 注意这里，只在摆动变化的时候更新prediff
            }
        }
        return result;
    }
};

53. 最大子序和

题目链接:. - 力扣（LeetCode）

题面:

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和子数组(子数组 是数组中连续的非空元素序列)是数组中的一个连续部分。

思路:

如果要硬找，那就需要两层for循环：

第一层 for 就是设置起始位置，第二层 for 循环遍历数组寻找最大值

那这道题如果用贪心贪的是哪里呢？

如果 -2 1 在一起，计算起点的时候，一定是从 1 开始计算，因为负数只会拉低总和，这就是贪心贪的地方！

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

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

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

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

这相当于是暴力解法中的不断调整最大子序和区间的起始位置。

那有同学问了，区间终止位置不用调整么？如何才能得到最大“连续和”呢？

区间的终止位置，其实就是如果 count 取到最大值了，及时记录下来了：

if (count > result) result = count;

这样相当于是用 result 记录最大子序和区间和（变相的算是调整了终止位置）。

代码实现:

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