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

455.分发饼干

这个问题的最优子结构体现在：我们可以通过逐步解决更小的子问题来构建全局最优解。具体来说，在每一步，我们都选择当前最小且能满足孩子需求的饼干，这个选择是局部最优的。通过这种方式，我们可以确保每个孩子尽可能得到一个饼干，从而最大化满足的孩子数量。问题的最优解可以通过递归地解决这些更小的子问题（即为每个孩子分配一个合适的饼干）并组合它们得到。所以，整个问题的最优解依赖于子问题的最优解，这就是问题的最优子结构。

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        s.sort()
        g.sort()
        res = 0
        child, biscuit = 0, 0
        while child < len(g) and biscuit < len(s):
            if g[child] <= s[biscuit]:
                res += 1
                child += 1
            biscuit += 1
        return res

376. 摆动序列

贪心法：

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

        for i in range(1, len(nums)):
            if pre is None and nums[i] != nums[i - 1]:
                res += 1
            elif pre is not None and pre * (nums[i] - nums[i - 1]) < 0:
                res += 1
            if nums[i] != nums[i - 1]:
                pre = nums[i] - nums[i - 1]

        return res

动态规划法：

class Solution:
    def wiggleMaxLength(self, nums: List[int]) -> int:
        dp = [[1] * 2 for i in range(len(nums))]

        for i in range(1, len(nums)):
            if nums[i] == nums[i - 1]:
                dp[i][0] = dp[i - 1][0]
                dp[i][1] = dp[i - 1][1]
            elif nums[i] > nums[i - 1]:
                dp[i][0] = max(dp[i - 1][1] + 1, dp[i - 1][0])
            else:
                dp[i][1] = max(dp[i - 1][0] + 1, dp[i - 1][1])
        return max(dp[len(nums) - 1][0], dp[len(nums) - 1][1])

53. 最大子序和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        pre, res = 0, float('-inf')
        for num in nums:
            pre += num
            if res < pre:
                res = pre
            if pre < 0:
                pre = 0
        return res