算法工程师重生之第二十三天（理论基础分发饼干摆动序列最大子序和）

最新推荐文章于 2024-10-09 22:28:58 发布

LookCodes

最新推荐文章于 2024-10-09 22:28:58 发布

阅读量432

点赞数 15

文章标签：算法

本文链接：https://blog.csdn.net/rgz147123/article/details/142767385

版权

参考文献代码随想录

一、理论基础

贪心一般解题步骤

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

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

这个四步其实过于理论化了，我们平时在做贪心类的题目很难去按照这四步去思考，真是有点“鸡肋”。

做题的时候，只要想清楚局部最优是什么，如果推导出全局最优，其实就够了。

二、分发饼干

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

对每个孩子 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。

示例 2:

输入: g = [1,2], s = [1,2,3]
输出: 2
解释: 
你有两个孩子和三块小饼干，2 个孩子的胃口值分别是 1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出 2。

提示：

1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1

问题分析

如果你是想拿小的饼干满足胃口大的孩子，这样会造成资源的浪费，在处理多个孩子和饼干时，如果优先考虑小饼干，可能会错过那些能够同时满足更多孩子的组合。例如，如果你有一个大胃口的孩子和几个小胃口的孩子，优先用小饼干会使得大胃口的孩子无法得到合适的饼干，而大饼干则会被闲置。假设有孩子胃口值为 [5, 10, 2] 和饼干尺寸为 [1, 2, 3, 6]。如果你首先尝试用小饼干去满足，可能会先用 1 去满足 2，然后用 2 去满足 5，最后剩下的 6 无法满足任何孩子，因为没有合适的匹配。而如果从最大的饼干 6 开始，直接满足胃口值为 5 的孩子，接下来可以用 3 满足胃口值为 2 的孩子，这样总共能满足两个孩子。所以只能大的满足大的，小的满足小的，这里不能使用2层循环，因为这样会重复的比较，导致结果会增多，这里只需要一层循环即可，只有满足了一个孩子胃口的需求，才判断另一个。然后大满足大的，的顺序可以颠倒吗？答案不可以，先遍历胃口，如果你先遍历的是饼干，那么如果当前的最大饼干满足不了当前的胃口，那么就会一直遍历到低，最后是0.

大满足大的

class Solution(object):
    def findContentChildren(self, g, s):
        """
        :type g: List[int]
        :type s: List[int]
        :rtype: int
        """
        # 贪心的 思路 尽量那小的饼干去满足胃口大的，这样 的思路会导致资源的浪费，所以大饼干对应大的胃口
        g.sort()
        s.sort()
        
        count = 0
        index = len(s) - 1
        for i in range(len(g) - 1, -1, -1):
            if index >= 0 and s[index] >= g[i]:  # 只要满足了才能往前比较，这里不能使用2层循环，因为这样会重复比较 
                count += 1
                index -= 1
        return count

小满足小的

class Solution(object):
    def findContentChildren(self, g, s):
        """
        :type g: List[int]
        :type s: List[int]
        :rtype: int
        """
       
        g.sort()
        s.sort()
        
        index = 0
        for i in range(len(s)):  # 遍历饼干
            if index < len(g) and g[index] <= s[i]:  # 如果当前孩子的贪心因子小于等于当前饼干尺寸
                index += 1  # 满足一个孩子，指向下一个孩子
        return index  # 返回满足的孩子数目

双指针法：使用两个指针，分别指向孩子和饼干：

如果当前饼干的尺寸能够满足当前孩子的胃口值，就分配这块饼干给这个孩子，并移动到下一个孩子和下一个饼干。
如果当前饼干的尺寸不能满足当前孩子的胃口值，就移动到下一个饼干，尝试用更大的饼干来满足这个孩子。

class Solution(object):
    def findContentChildren(self, g, s):
        """
        :type g: List[int]
        :type s: List[int]
        :rtype: int
        """
      
        g.sort()
        s.sort()
        
        child_i = 0  # 孩子指针
        cookie_j = 0  # 饼干指针
        satisfied_children = 0  # 满足的孩子数量

        # 直到我们遍历完所有孩子或所有饼干
        while child_i < len(g) and cookie_j < len(s):
            if s[cookie_j] >= g[child_i]:  # 如果当前饼干可以满足当前孩子
                satisfied_children += 1  # 满足一个孩子
                child_i += 1  # 下一个孩子
            cookie_j += 1  # 移动到下一个饼干

        return satisfied_children

三、摆动序列

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

例如， [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) 。

示例 3：

输入：nums = [1,2,3,4,5,6,7,8,9]
输出：2

提示：

1 <= nums.length <= 1000
0 <= nums[i] <= 1000

问题分析

本题要求通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

相信这么一说吓退不少同学，这要求最大摆动序列又可以修改数组，这得如何修改呢？

来分析一下，要求删除元素使其达到最大摆动序列，应该删除什么元素呢？

用示例二来举例，如图所示：

376.摆动序列

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

局部最优推出全局最优，并举不出反例，那么试试贪心！

（为方便表述，以下说的峰值都是指局部峰值）

实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）

这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点

在计算是否有峰值的时候，大家知道遍历的下标 i ，计算 prediff（nums[i] - nums[i-1]）和 curdiff（nums[i+1] - nums[i]），如果prediff < 0 && curdiff > 0 或者 prediff > 0 && curdiff < 0 此时就有波动就需要统计。

这是我们思考本题的一个大体思路，但本题要考虑三种情况：

情况一：上下坡中有平坡
情况二：数组首尾两端
情况三：单调坡中有平坡

#情况一：上下坡中有平坡

例如 [1,2,2,2,1]这样的数组，如图：

它的摇摆序列长度是多少呢？ 其实是长度是 3，也就是我们在删除的时候要不删除左面的三个 2，要不就删除右边的三个 2。

如图，可以统一规则，删除左边的三个 2：

在图中，当 i 指向第一个 2 的时候，prediff > 0 && curdiff = 0 ，当 i 指向最后一个 2 的时候 prediff = 0 && curdiff < 0。

如果我们采用，删左面三个 2 的规则，那么当 prediff = 0 && curdiff < 0 也要记录一个峰值，因为他是把之前相同的元素都删掉留下的峰值。

所以我们记录峰值的条件应该是： (preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)，为什么这里允许 prediff == 0 ，就是为了上面我说的这种情况。

#情况二：数组首尾两端

所以本题统计峰值的时候，数组最左面和最右面如何统计呢？

题目中说了，如果只有两个不同的元素，那摆动序列也是 2。

例如序列[2,5]，如果靠统计差值来计算峰值个数就需要考虑数组最左面和最右面的特殊情况。

因为我们在计算 prediff（nums[i] - nums[i-1]）和 curdiff（nums[i+1] - nums[i]）的时候，至少需要三个数字才能计算，而数组只有两个数字。

这里我们可以写死，就是如果只有两个元素，且元素不同，那么结果为 2。

不写死的话，如何和我们的判断规则结合在一起呢？

可以假设，数组最前面还有一个数字，那这个数字应该是什么呢？

之前我们在讨论情况一：相同数字连续的时候， prediff = 0 ，curdiff < 0 或者 >0 也记为波谷。

那么为了规则统一，针对序列[2,5]，可以假设为[2,2,5]，这样它就有坡度了即 preDiff = 0，如图：

376.摆动序列1

针对以上情形，result 初始为 1（默认最右面有一个峰值），此时 curDiff > 0 && preDiff <= 0，那么 result++（计算了左面的峰值），最后得到的 result 就是 2（峰值个数为 2 即摆动序列长度为 2）

经过以上分析后，我们可以写出如下代码：

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

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

此时大家是不是发现以上代码提交也不能通过本题？

所以此时我们要讨论情况三！

#情况三：单调坡度有平坡

在版本一中，我们忽略了一种情况，即如果在一个单调坡度上有平坡，例如[1,2,2,2,3,4]，如图：

图中，我们可以看出，版本一的代码在三个地方记录峰值，但其实结果因为是 2，因为单调中的平坡不能算峰值（即摆动）。

之所以版本一会出问题，是因为我们实时更新了 prediff。

那么我们应该什么时候更新 prediff 呢？

我们只需要在这个坡度摆动变化的时候，更新 prediff 就行，这样 prediff 在单调区间有平坡的时候就不会发生变化，造成我们的误判。

贪心

class Solution(object):
    def wiggleMaxLength(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) <= 1:
            return  len(nums)
        curDiff = 0  # 当前一对元素的差值
        preDiff = 0  # 前一对元素的差值
        result = 1  # 记录峰值的个数，初始为1（默认最右边的元素被视为峰值）
        for i in range(len(nums) - 1):
            curDiff = nums[i + 1] - nums[i]  # 计算下一个元素与当前元素的差值
            # 如果遇到一个峰值
            if (preDiff <= 0 and curDiff > 0) or (preDiff >= 0 and curDiff < 0):
                result += 1  # 峰值个数加1
                preDiff = curDiff  # 注意这里，只在摆动变化的时候更新preDiff
        return result  # 返回最长摆动子序列的长度

动态规划

class Solution:
    def wiggleMaxLength(self, nums):
        if len(nums) <= 1:
            return len(nums)  # 如果数组长度为0或1，则返回数组长度
        
        up = down = 1  # 记录上升和下降摆动序列的最大长度
        for i in range(1, len(nums)):
            if nums[i] > nums[i-1]:
                up = down + 1  # 如果当前数比前一个数大，则可以形成一个上升峰值
            elif nums[i] < nums[i-1]:
                down = up + 1  # 如果当前数比前一个数小，则可以形成一个下降峰值
        return max(up, down)  # 返回上升和下降摆动序列的最大长度

四、最大子数组和

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

子数组

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

示例 1：

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

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104

暴力

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #组合：组合指的是从一个集合中选择若干元素，而不考虑它们的顺序。例如，从数组 [1, 2, 3] 中可以得到的组合包括 {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, 和 {1, 2, 3} 等。
        #连续子序列：连续子序列是指数组中相邻元素的选择，其顺序保持不变。例如，在数组 [1, 2, 3] 中，可能的连续子序列包括 [1], [2], [3], [1, 2], [2, 3], 和 [1, 2, 3]。

        result = float('-inf')  # 初始化结果为负无穷大
        count = 0
        for i in range(len(nums)):  # 设置起始位置
            count = 0
            for j in range(i, len(nums)):  # 从起始位置i开始遍历寻找最大值
                count += nums[j]
                result = max(count, result)  # 更新最大值
        return result

贪心

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        #组合：组合指的是从一个集合中选择若干元素，而不考虑它们的顺序。例如，从数组 [1, 2, 3] 中可以得到的组合包括 {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, 和 {1, 2, 3} 等。
        #连续子序列：连续子序列是指数组中相邻元素的选择，其顺序保持不变。例如，在数组 [1, 2, 3] 中，可能的连续子序列包括 [1], [2], [3], [1, 2], [2, 3], 和 [1, 2, 3]。

        result = float("-inf")
        sumN = 0
        for i in range(len(nums)):
            sumN += nums[i]
            result = max(result, sumN)  # 每次记录 有可能成为最大的和
            if sumN < 0:  # 如果和已经为负数了，那么在加的话它会拉低总的和
                sumN = 0
        return result