代码随想录算法训练营Day31 | 贪心算法理论 | 455. 分发饼干 | 376. 摆动序列 | 53. 最大子序和

贪心算法理论

做到每一阶段的局部最优，可以得到全局最优。但是每一阶段的最优是本地的，不依赖之后的选择。因此，贪心算法的顺序通常是自上而下的。作为对比，动态规划（DP）的顺序是自下而上的，每一步选择依赖于当前问题的子问题（下一步）结果。

选择贪心算法的时机：模拟一下，感觉可以局部最优推出全局最优，也想不到什么反例，那就可以尝试贪心算法。

理论上的四步：

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

实际上的贪心算法，最困难的是找到正确的贪心策略，从而使局部最优推导出全局最优，这一步是捉摸不定，没有规律的。

455. 分发饼干

题目链接 | 解题思路

直觉上，为了最大化满足的孩子的数量，要尽可能利用好每一块饼干。于是，思路可以是“大饼干喂给大孩子” 或 “小饼干喂给小孩子”。这两种局部最优都不依赖于任何子问题，直接基于当前的条件进行选择。

这两种不同的思路，代码的写法也不同，要注意所循环的数组是哪一个（哪个变量是动态变化的）。

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        count = 0
        g.sort()
        s.sort()
        child_idx = 0
        for cookie_idx in range(len(s)):
            if child_idx == len(g):
                break
            if s[cookie_idx] >= g[child_idx]:
                child_idx += 1
                count += 1
        return count

376. 摆动序列

题目链接 | 解题思路

首先注意到题目只要求最长摆动子序列的长度，所以没必要记录最长的摆动子序列，一个计数器即可。

贪心算法的逻辑：从头开始，依次删除数列中所有单调子序列中的非首尾元素，剩下的就是最长的摆动序列。
局部最优：删除当前单调子序列中的非首尾元素。

自然的，我们会记录如下两个变量：
prev_diff := nums[i+1] - nums[i] 后一个元素与当前元素值的差
curr_diff := nums[i] - nums[i-1] 当前元素与前一个元素值的差
当这两个变量值的符号不同时，就遇到了一个摆动的峰值。这里，prev_diff * curr_diff < 0 实际上确定了两个摆动序列的元素，即 nums[i] 和 nums[i+1]。因为无论 nums[i+1] 后面的元素如何变化，nums[i+1] 都是摆动序列的一部分。这导致摆动序列的最后一个元素不会被这个条件所确定，所以 count 初始化为 1。

有三种情况需要考虑：

1. 存在一个子序列，首尾均属于摇摆序列，但是中间存在相同元素（平坡）
   

   这种情况可以选择仅保留平坡的第一个或最后一个元素。保留最后一个元素，则允许 prev_diff=0，只要 curr_diff 确定不为 0 即可，此时可以将当前元素加入摆动子序列。

2. 首尾两端
   题目中规定，如果数组长度为1，则默认为摆动序列；如果长度为2，且两个元素值不等，则为摆动序列。这样的情况可以单独列出 if 考虑，也可以在数组开头添加一个和 nums[0] 相等的元素。这两种方法都使得 prev_diff 应该初始化为 0，从而可以正常计算数组的第一个元素。

3. 单调序列中存在平坡
   之前的双指针中，慢指针的更新一般依赖于快指针是否满足特定条件。之前的两种情况中，每次移动都会进行更新 prev_diff = curr_diff，这使得单调序列中的平坡的最后一个元素（saddle point）也会被认为是摆动序列的一个元素。
   
   修改方案是，只有当前元素之后出现了明确的变化（curr_diff > 0 或 curr_diff < 0），才进行 prev_diff 的更新。这样保证了prev_diff 记录了前一次变化的更新，而非当前元素和前一个元素的差。
   值得一提的是，这样的更新条件导致 prev_diff=0 仅仅会出现在数组的开头。

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return 1

        if len(nums) == 2:
            if nums[0] != nums[1]:
                return 2
            else:
                return 1
        
        prev_diff = 0
        curr_diff = 0
        count = 1
        for idx in range(len(nums) - 1):
            curr_diff = nums[idx+1] - nums[idx]
            if prev_diff >= 0 and curr_diff < 0:        # diff changes: increase -> decrease
                count += 1
            if prev_diff <= 0 and curr_diff > 0:        # diff changes: decrease -> increase
                count += 1
            if curr_diff != 0:
                prev_diff = curr_diff
        return count

动态规划

创建一个二维的 dp 数组。输入中的任意一个数，都是某一个摆动序列的某个峰值/谷值（即使是 [1, 1, 1] 中的最后一个 1，也是以自己为开头和结尾的单元素摆动序列的峰值/谷值）。

• dp[i][0]：当前 nums[:i] 中以 i 为峰值的最长摆动序列的长度
• dp[i][1]：当前 nums[:i] 中以 i 为谷值的最长摆动序列的长度

状态转移等式为：

• 0 < j < i, nums[j] < nums[i]，则 dp[i][0] = max(dp[i][0], dp[j][1] + 1)
• 0 < j < i, nums[j] > nums[i]，则 dp[i][1] = max(dp[i][1], dp[j][0] + 1)

初始状态，每个数只考虑自己也一定有长度为 1 的摆动序列，所以初始化均为 1。

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        dp = [[1, 1] for _ in range(len(nums))]
        for i in range(1, len(nums)):
            for j in range(i):
                if nums[j] < nums[i]:
                    dp[i][0] = max(dp[i][0], dp[j][1] + 1)
            for j in range(i):
                if nums[j] > nums[i]:
                    dp[i][1] = max(dp[i][1], dp[j][0] + 1)
        return max(dp[-1][0], dp[-1][1])

53. 最大子序和

题目链接 | 解题思路

局部最优：如果当前记录的连续区间和为负数，结束当前区间；从下一个元素开始记录新的连续区间。负的连续和只会导致接下来的连续区间和越来越小（趁早甩掉累赘）。

这样的方法不断调整连续区间的起始位置，也就是贪心的优势所在，不需要像暴力算法一样不断从头开始。
对于连续区间的终止点，不用刻意记录。每次当前连续和超过记录的最大连续和时，更新最大连续和即可，这样保证了不用刻意记录终止点，也能得到最大的连续和。

负数与起始位置之间的关系是本题的难点，记录的最大连续和很好地解决了这个问题。要意识到“连续和为负数时，应该放弃当前区间，另起新区间；否则负的连续和只会不断拖累后面的正数”，则是本题的贪心逻辑。

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

动态规划

dp[i]记录的是 nums[:i+1] 中以 nums[i] 为结尾的最大连续子数组的和。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [float('-inf')] * len(nums)
        dp[0] = nums[0]
        for i in range(1, len(nums)):
            dp[i] = max([dp[i-1] + nums[i], nums[i]])
        return max(dp)