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

第八章 贪心算法

理论基础

1 什么是贪心？
贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
举一个例子：

例如，有一堆钞票，你可以拿走十张，如果想达到最大的金额，你要怎么拿？
指定每次拿最大的，最终结果就是拿走最大数额的钱。
每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。
再举一个例子如果是 有一堆盒子，你有一个背包体积为n，如何把背包尽可能装满，如果还每次选最大的盒子，就不行了。这时候就需要动态规划。

2 贪心的套路（什么时候用贪心）
贪心算法并没有固定的套路。
所以唯一的难点就是如何通过局部最优，推出整体最优。

那么如何能看出局部最优是否能推出整体最优呢？有没有什么固定策略或者套路呢？

不好意思，也没有！ 靠自己手动模拟，如果模拟可行，就可以试一试贪心策略，如果不可行，可能需要动态规划。
有同学问了如何验证可不可以用贪心算法呢？

最好用的策略就是举反例，如果想不到反例，那么就试一试贪心吧。

一般数学证明有如下两种方法：

数学归纳法
反证法

面试中基本不会让面试者现场证明贪心的合理性，代码写出来跑过测试用例即可，或者自己能自圆其说理由就行了。
刷题或者面试的时候，手动模拟一下感觉可以局部最优推出整体最优，而且想不到反例，那么就试一试贪心。

贪心一般解题步骤
贪心算法一般分为如下四步：

1. 将问题分解为若干个子问题
2. 找出适合的贪心策略
3. 求解每一个子问题的最优解
4. 将局部最优解堆叠成全局最优解

贪心没有套路，说白了就是常识性推导加上举反例。

455.分发饼干

题目链接

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

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

思路： 双指针法 + 贪心 + 排序
这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

1、可以先对给的两个数组进行排序，那么得到的数组就是一个有序数组
2、通过从后向前遍历，这里的理解是：当我把最大的“胃口”满足了以后，我再向前移动，直到不能满足每一个。
3、遍历的是“胃口”而不是饼干，遍历饼干会导致出错

代码中用了一个index来控制饼干遍历的数组，，遍历饼干并没有再起一个for循环，而是采用自减的方式，这也是常用的技巧。（这个技巧挺关键的，需要经常）

// 版本一 
// 时间复杂度：O(nlogn)
// 空间复杂度：O(1)
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;
    }
};

总结： 贪心算法再一定程度上比较难想，但是这道题属于入门题，重要的还是要想清楚局部最优，想清楚全局最优，感觉局部最优是可以推出全局最优，并想不出反例，那么就试一试贪心。

376. 摆动序列 （动态规划的时候再用动态规划解决本题）

题目链接

思路： 一刷没什么思路，主要还是通过看视频得到思路：
1、定义两个变量，分别判断左右两边的坡度，当出现一个为正一个为负的时候表明此时有摆动，需要记录摆动。
2、数组首尾两端的的时候，此时定义的前一个变量，我们定义了一个初值为0，可以类比为它前面有个相同的值，没有坡度，也可以满足上面的条件
3、单调有平坡，就是一直是王上的情况，中间出现平坡，如果我们每次判断都更新了前一个坡度，那么就会导致这种情况报错，我们只需要在记录返回值的时候再对前一个坡度进行调整。

用prediff和curdiff来比较，这个办法需要多练习才能解决：

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;
    }
};

总结： 看完视频不难，但是自己做的时候还是会感觉比较不容易想，三种情况很难能一次性讨论完。
本题异常情况的本质，就是要考虑平坡， 平坡分两种，一个是 上下中间有平坡，一个是单调有平坡，如图：

思路2 动态规划（学到动态规划的时候再来解决本次问题）

53. 最大子序和

题目链接
给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

思路： ：

1、贪心算法
用一个变量记录连续和，当出现负数的时候我们整个抛弃这个结果，然后从下一个开始继续求连续和
用另外一个变量记录结果，当连续和大于当前的这个结果，那么就更新，最后返回

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; // 赋值为0 是为了从下一个nums[i] 开始  count += nums[i];
        }
        return result;
    }
};

总结 因为这道题之前做过，所以还有一点印象，不过那个时候还不知道具体的每种算法名字，所以现在来整体解释一下。

这道题还有动态规划解法，到后面专题了再来解决一次。