算法刷题Day31 | 455.分发饼干、376. 摆动序列、53. 最大子数组和

news2025/2/26 6:16:07

0 引言

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

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

这个四步其实过于理论化了，我们平时在做贪心类的题目很难去按照这四步去思考，真是有点“鸡肋”。
做题的时候，只要想清楚局部最优是什么，如果推导出全局最优，其实就够了。

1 分发饼干

🎈 文档讲解
🎈 视频讲解
🎈 做题状态：

1.1 我的解题

我的想法，遍历饼干，然后再从大到小遍历孩子的胃口。找到刚好匹配的数就结果加一，然后把这个胃口数据移除。

#include <algorithm>

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int count = 0;

        // 先将数组排序
        sort(g.begin(), g.end());
        sort(s.begin(), s.begin());

        // 初步思考，使用两层循环遍历，先遍历饼干，再遍历胃口
        for (int i = 0; i < s.size(); i++)
        {
            for (int j = g.size()-1; j >= 0; j--)
            {
                if (s[i] < g[j])
                {
                    continue;
                }
                else
                {
                    count++;
                    g.erase(g.begin() + j);
                    break;
                }
            }
        }

        return count;
    }
};

1.2 更好的解题

只用了一个循环模拟了胃口和饼干的同时遍历。
先遍历大饼干，先满足胃口大的小孩。

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

2 摆动序列

🎈 文档讲解
🎈 视频讲解
🎈 做题状态：

2.1 我的解题

本题难点：
是求的子序列，子序列的话是可以从原始序列中删除元素的。所以比较难判断。

下面是我的错误代码。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() == 1) return 1;
        if (nums.size() == 2 && nums[0] != nums[1]) return 2;

        int count = 2;
        int maxCount = count;
        // 此时数组个数大于等于3
        for (int i = 2; i < nums.size(); i++)
        {
            int diff1 = nums[i] - nums[i-1];
            int diff2 = nums[i-1] - nums[i-2];
            // cout << "diff1 = " << diff1 << endl;
            // cout << "diff2 = " << diff2 << endl;
            if ((diff > 0 && prevDiff < 0) || (diff < 0 && prevDiff > 0))
            {
                if (diff1 != 0 && diff2 != 0)
                {
                    count++;
                }
            }
            else
            {
                // 如果不满足则count重置为2，同时将不满足的数给删除
                //count = 2;
                nums.erase(nums.begin() + i - 1);
                i--;
            }
            maxCount = max(maxCount, count);
            cout << "count = " << count << endl;
        }

        return maxCount;
    }
};

2.2 我的错误原因（GPT分析）

您的代码试图解决的问题是寻找给定数组中最长的摆动子序列的长度。摆动序列被定义为序列中的数字交替大于和小于其前一个数字。您的实现逻辑有几个关键的缺陷和改进点：

数组修改： 您尝试通过删除不符合摆动序列条件的元素来维护摆动序列，这不仅改变了原数组，而且并不是解决这个问题的有效方法。在寻找最长摆动序列时，我们并不需要修改原数组，而是应该寻找一种方式来识别摆动序列的长度而不实际改变数组内容。
摆动序列的识别： 您的逻辑试图通过比较当前元素与前两个元素的差来确定是否构成摆动。虽然这种思路基本正确，但其实现方式过于复杂，且erase操作导致时间复杂度增加。此外，您的条件检查(diff1 == abs(diff1) && diff2 == -abs(diff2) || diff2 == abs(diff2) && diff1 == -abs(diff1))可以简化为检查diff1和diff2的符号是否相反。
初始化问题： 初始的count设置为2是基于至少存在一对不同的元素。如果数组开始就有连续相等的元素，这种初始化是不准确的。

为了改进您的代码，可以采取以下策略：

初始化时考虑特殊情况： 首先处理只有一个元素或所有元素都相等的情况。
使用状态变量： 记录最后一次摆动是上升还是下降，而不是每次都检查三个元素。
避免修改原数组： 直接通过遍历原数组来判断每一步是否构成摆动，不需要修改原数组。

下面是一个改进后的实现示例：

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int n = nums.size();
        if (n < 2) return n;
        
        // 初始化计数器和方向
        int count = 1; // 至少有一个元素，所以从1开始计数
        int prevDiff = 0;
        
        for (int i = 1; i < n; ++i) {
            int diff = nums[i] - nums[i-1];
            if ((diff > 0 && prevDiff <= 0) || (diff < 0 && prevDiff >= 0)) {
                // 发现摆动，增加计数并更新prevDiff
                count++;
                prevDiff = diff;
            }
        }
        
        return count;
    }
};

这个实现不修改原数组，通过遍历数组一次，比较相邻元素之差来判断摆动，并且只在摆动方向发生变化时增加计数器。这种方式更为简洁且效率更高。

2.3 改进

不能将峰值删除，相当于求极值点有几个。看了视频发现有平坡的情况需要很多特殊讨论，那么可不可以直接把数据的平坡给去除呢？然后再来做题。使用遍历把相邻相同的数据给去除。

3 最大子数组和

🎈 文档讲解
🎈 视频讲解
🎈 做题状态：

3.1 我的解题

首先明确思路：
最大和的子数组，然后每次移动记录数组和，如果遇到sum小于0，则可以直接将sum置为0，然后从后面遇到的第一个正数开始记录。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = nums[0];
        int sum = 0;
        for (int i = 0; i < nums.size(); i++)
        {
            sum += nums[i];
            result = max(result, sum);
            if (sum <= 0)
            {
                sum = 0;
            }
        }
        return result;
    }
};