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

今日内容

贪心理论基础
Leetcode. 455 分发饼干
Leetcode. 376 摆动序列
Leetcode. 53 最大子序和

贪心理论基础

贪心算法的本质就是选择每一阶段的最优，达到全局上的最优。

贪心算法和之前学到的所有方法相比，它没有固定的使用套路，也没有固定的验证法来确认本题是否适用贪心算法。

对于何时应该使用贪心，那就只能手动模拟推导一下。如果模拟推导感觉可以根据局部最优推出全局最优，并且也找不出反例的话，就用贪心吧。

Leetcode. 455 分发饼干

文章链接：代码随想录 (programmercarl.com)

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

本题的局部最优就是拿目前最大的饼干来满足胃口最大的孩子，从而达到全局最优：尽可能多的孩子被喂饱。而且似乎也找不出反例，那么就可以使用贪心算法解决。

因此，可以写出如下代码：

java 复制代码

class Solution {
    // 从大到小进行贪心
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int index = s.length - 1;
        int result = 0;
        for (int i = g.length - 1; i >= 0; i--){ // 注意这里遍历的是 胃口
            if (index >= 0 && s[index] >= g[i]){
                index--;
                result++;
            }
        }
        return result;
    }
}

时间复杂度：O(nlogn)
空间复杂度：O(1)

注意代码中，for 循环是在表示小孩胃口的数组中进行遍历的，这样是必须的。因为假如对饼干尺寸数组进行遍历，则可能遇到如下图所示情况：

即饼干尺寸数组遍历完也找不到一个匹配当前孩子胃口的结果，进而影响结果。如果我们的贪心思想是先用尺寸小的饼干满足小胃口的孩子优先的话，此时遍历饼干尺寸数组是正确的。

Leetcode. 376 摆动序列

文章链接：代码随想录 (programmercarl.com)

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

本题的局部思想就是获取单调坡上的两端节点，不理会单调坡中间的节点，获取两个局部峰值。使整个序列的局部峰值最多，就可以获得全局最优：得到最长摆动序列。

要想知道当前节点是否为单调坡的两端，就需要知晓该节点的前坡值 pre 和后坡值 next。其中 pre = nums[i] - nums[i - 1]，next = nums[i + 1] - nums[i]。当 pre > 0, next < 0 或 pre < 0, next > 0时就说明当前节点是坡的两端。

知晓了两端的判断方式，就需要列出单调坡中可能出现的情况：

上下坡中有平坡 。如图所示，此时要么去除前三个重复元素，要么去除后三个重复元素。所以考虑这种情况后，上面的条件就变为了当 pre >= 0, next < 0 或 pre <= 0, next > 0 时就说明当前节点是坡的两端。
数组首位两端 。假如整个数组只有两个元素，根据上述的前后坡值是无法计算出来的，因为这样需要三个元素得出。因此可以假设最左边的元素前有个平坡，然后最右边的元素自动视作是一个峰值。

根据上述两种情况可以写出如下代码：

java 复制代码

// 版本一
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;
    }
};

但这个代码依然完成不了，原因就在于 preDiff = curDiff 这一行。

实际上，除了上述两个情况以外还有一个情况：单调坡上有个平坡。

面对这种情况，如果根据版本一的代码所示，遍历每个元素时都更新一次前坡值，那么它会把第三个 2 认为是一次摆动，但实际上这只是单调坡上的平坡的一个转折点，并没有摆动。

要想解决该情况，则需要在摆动真正发生时更新前坡值。因此，改良后的代码如下：

java 复制代码

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int pre = 0;
        int cur = 0;
        int result = 1; // 默认最右边的元素算一个摆动序列
        for (int i = 0; i < nums.length - 1; i++){ // 注意条件表达式已经将最后一个元素排除
            cur = nums[i + 1] - nums[i];
            if (pre >= 0 && cur < 0 || pre <= 0 && cur > 0){
                result++;
                pre = cur; // 摆动发生时才更新前坡值
            }
        }
        return result;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

Leetcode. 53 最大子序和

文章链接：代码随想录 (programmercarl.com)

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

本题的**局部最优就是当前元素若加入进来后导致总和为负数后，则重新求和。**因为本题要求最大的连续子序，所以当总和为负数后，总是会拉低得到的结果，因此碰到使总和为负数的元素时就重置总和。

本题思路如下图所示：

写出如下代码：

java 复制代码

class Solution {
    public int maxSubArray(int[] nums) {
        int result = Integer.MIN_VALUE;
        int count = 0;
        for (int i = 0; i < nums.length; i++){
            count += nums[i];
            if (count > result){ // 记录当前最大总和
                result = count;
            }
            if (count < 0){count = 0;} // 当总和为负数时，重置
        }
        return result;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)

总结

贪心算法真是给了个下马威，一下子难以彻底消化贪心算法的使用。

目前看来，贪心算法最重要的还是找到题目中**什么是局部最优，**这样才好进行下一步。