算法学习打卡day31｜贪心算法、455.分发饼干、 376. 摆动序列、53. 最大子序和

贪心算法

• 贪心的本质是选择每一阶段的局部最优，从而达到全局最优。
• 大概分为四个步骤分析问题：
  1. 将问题分解为若干个子问题
  2. 找出适合的贪心策略
  3. 求解每一个子问题的最优解
  4. 将局部最优解堆叠成全局最优解
• 一般情况下下，如果可以通过局部最优实现全局最优，且列举不出来反例，就可以试试贪心算法

455.分发饼干

力扣题目链接
题目描述：
假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

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

示例 1:

输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

思路：

• 每个孩子的胃口不一样，且饼干的尺寸也不一样，我们只要每次把最大的饼干分给能满足最大胃口的孩子，就一定能分给更多的人，当然每次讲最小的饼干，分给能满足越小胃口的孩子也是可以的。
• 怎么实现呢？
• 只要将两个数组分别排序，然后同时从后遍历或者从前遍历匹配即可。
• 注意：
  • 这里其实不需要双层for循环，但优化后的循环顺序需要注意：
  • 先匹配胃口小的孩子的时候，如果饼干在外层循环的时候，最小的饼干都无法满足最小的胃口，那么只能往后找再大一点的饼干去满足了，但是如果胃口在外层的话，小胃口无法匹配小饼干，但是没准后面的大饼干会满足这个小胃口呢？但是由于for循环，这个小胃口就被跳过了！同理先匹配胃口大的孩子也是这个逻辑，用胃口数组去执行循环。

代码实现：

//先匹配大的
int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int count = 0;
        int last = s.size() - 1;
        for (int i = g.size() - 1; i >= 0; --i) {
            if (last >= 0 && g[i] <= s[last]) {
                count++;
                last--;
            }
        }
        return count;
    }

//先匹配小的
int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        int count = 0;
        int last = 0;
        for (int i = 0; i < s.size(); ++i) {
            if (last < g.size() && g[last] <= s[i]) {
                count++;
                last++;
            }
        }
        return count;
    }

376. 摆动序列

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

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

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

示例 1：

输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。
示例 2：

输入：nums = [1,17,5,10,13,15,10,5,16,8]
输出：7
解释：这个序列包含几个长度为 7 摆动序列。
其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。

思路：

• 贪心法：

  • 这道题分析起来易错点在条件判断处，很容易遗漏，摆动序列就是当前相邻两个元素之差，和上一组相邻元素之差互为相反数，几何图像呈现出来是，上下摆动的，那么很显然可以写出，如下判断条件：pre_diff > 0 && cur_diff < 0 || pre_diff < 0 && cur_diff > 0，然后符合条件就result + 1。
  • 由于可能会出现平坡的现象，那么我们遇到此种现象需要跳过多余的数字（不要陷入删除的逻辑，根本不需要特地去判断再删除，不要被题目迷惑），留左边或者右边的数字都可以，此时只需要修改下判断条件：pre_diff >= 0 && cur_diff < 0 || pre_diff <= 0 && cur_diff > 0。
  • 为什么加个等于判断就可以了？
  • 因为假如遇到pre_diff不为0,cur_diff为0的时候，我们没有去处理，而中间不论多少相同数字也不会去处理，因为都不符合条件，直到最后一组，pre_diff为0，cur_diff不为0时，我们将result + 1，此时正是我们需要的，result只被加了一次。（当然将&&后面的写为0也行）
  • 当只有两个元素时，怎么处理呢，由于要计算pre和cur至少需要三个元素，此时我们就将pre_diff当做0，然后只要两个元素不相等就符合条件，result + 1 = 2 了，否则就是1。

• 陷阱： 当本来序列为递增序列时，出现平坡，此种情况如果pre随着cur一直修改就是错误的，因为result被多加了一次，为什么？因为本来单调性就没变，即使遇到平坡也不应该让result + 1。

  • 解决方法：只有单调性改变的时候，pre再更新为cur即可。

• 动态规划法：

代码实现

int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() == 1) return 1;
        int result = 1;
        int pre_diff = 0, cur_diff = 0;
        for (int i = 1; i < nums.size(); ++i) {
            cur_diff = nums[i] - nums[i - 1];
            if (pre_diff >= 0 && cur_diff < 0 || pre_diff <= 0 && cur_diff > 0) {
                result++;
                pre_diff = cur_diff;
            }
        }
        return result;
    }

53. 最大子序和

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

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

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

思路：

• 滑动窗口法
  • fast指针先走，将数组指针加到sum上，**如果遇到sum小于0的情况就该缩小窗口了，因为此时再往后加的话，整体的和是减少的，不如直接重新的fast点开始继续求和，**此时让sum不断减去slow的值，直到sum大于等于0为止（其实slow走到fast处了）。
  • 注意：最大值是在sum改变之前判断的，否则遇到全部为负数的序列，还得在循环后单独判断，求数组最大值，因为如果放到sum改变之后的话，由于sum被减到0了，碰到全是负数的序列，那么max_sum就被赋值为0了，这是不对的，所以必须在sum更改之前就得取max了。
• 贪心法
  • 其实用动态规划法修改下就是贪心法了，逻辑基本一致，就是遇到sum小于0的时候，当前sum一定会降低后序元素相加的和，但是如果是非负数的话，不用担心后续求和之后整体变小，此时我们就把sum赋值为0，注意max取值要在sum改变之前。（并不好想出来）
• 动态规划法（后序再学）

代码实现

• 滑动窗口法

int maxSubArray(vector<int>& nums) {
        if (nums.size() == 1)   return nums[0];

        int max_sum = nums[0], sum = 0;
        int slow = 0;
        for (int fast = 0; fast < nums.size(); ++fast) {
            sum += nums[fast];
            max_sum = max_sum >= sum ? max_sum : sum;
            while (sum < 0) {
                sum -= nums[slow++];
            }
        }
        // //如果全为负，取最大值
        // if (sum == 0 && max_sum == 0) {
        //     max_sum = nums[0];
        //     for (int& i : nums) {
        //         max_sum = max_sum >= i ? max_sum : i; 
        //     }
        // }
        return max_sum;
    }

• 贪心法

int maxSubArray(vector<int>& nums) {
        if (nums.size() == 1)   return nums[0];

        int max_sum = INT_MIN, sum = 0;
        for (int i = 0; i < nums.size(); ++i) {
            sum += nums[i];
            max_sum = max_sum >= sum ? max_sum : sum; 
            sum = sum < 0 ? 0 : sum;
        }
        return max_sum;
    }