专题九  贪心算法

一、分发饼干

1.题目

Leetcode：第 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。

示例 2:

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

2.解题思路

使用贪心算法解决分发饼干问题。

1.先用大饼干去满足大胃口。在 findContentChildren 函数中，首先对两个数组 g 和 s 进行排序，这样可以实现贪心策略：将胃口最大的孩子与最大的饼干配对，然后继续为次胃口的孩子寻找次尺寸的饼干，依此类推。通过反向遍历孩子们的胃口程度数组 g，我们可以确保每个孩子都尽可能地被满足。index 变量用于跟踪当前考虑的饼干索引，result 变量用于记录能够满足的孩子数量。
在循环中，如果当前饼干的尺寸大于等于当前孩子的胃口，那么这个孩子就会被满足，result 增加，并且 index 减 1，表示已经用掉了一个饼干。这种方法可以确保在给定的饼干和孩子们的胃口下，最大化满足孩子的数量。

2.先用小饼干去满足小胃口，基本思路与1一致。

3.实现代码

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

// 一、分发饼干（用大饼干去满足大胃口）
class Solution1 {
public:
    // findContentChildren 函数用于找出能够满足的孩子们的数量
    int findContentChildren(vector<int>& g, vector<int>& s) { 
        sort(g.begin(), g.end());// 对孩子们的胃口程度数组进行升序排序
        sort(s.begin(), s.end());// 对饼干的尺寸数组进行升序排序
        int index = s.size() - 1;// 初始化 index 为饼干数组的最后一个索引
        int result = 0;// 初始化结果变量 result，用于记录满足的孩子数量
        // 从孩子们的胃口程度数组的最后一个开始向前遍历
        for (int i = g.size() - 1; i >= 0; i--) {
            // 当饼干数组的索引 index 未越界，并且当前饼干的尺寸大于等于当前孩子的胃口时
            if (index >= 0 && s[index] >= g[i]) {
                result++;// 一个孩子满足，增加结果计数
                index--;// 移动 index 到下一个饼干
            }
        }
        return result;// 返回能够满足的孩子们的数量
    }
};

// 二、分发饼干（用小饼干去满足小胃口）
class Solution2 {
public:
    // findContentChildren 函数用于找出能够满足的孩子们的数量
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end()); // 对孩子们的胃口大小数组进行升序排序
        sort(s.begin(), s.end());// 对饼干的大小数组进行升序排序
        int index = 0;// 初始化 index 为 0，用于记录当前满足的孩子的索引
        // 遍历所有饼干
        for (int i = 0; i < s.size(); i++) {
            // 检查是否存在一个孩子的胃口小于等于当前饼干的大小
            // 如果 index 小于 g 的大小，并且 g[index] 小于等于 s[i]，则说明当前饼干可以满足一个孩子
            if (index < g.size() && g[index] <= s[i]) {
                index++;// 一个孩子满足，增加 index，表示下一个孩子将被考虑
            }
            // 如果当前饼干不能满足任何孩子的胃口，继续寻找下一个饼干
        }
        return index;// 返回能够满足的孩子们的数量
    }
};

//测试
int main()
{
    Solution1 p;
    vector<int> g = { 1, 2, 3 };
    vector<int> s = { 1, 1 };
    int result = p.findContentChildren(g, s);
    cout << "能够满足的孩子们的数量 :" <<result<< endl;
    cout <<endl;
    return 0;
}

 

二、摆动序列

1.题目

Leetcode：第 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) 。

示例 3：

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

2.解题思路

使用贪心算法解决摆动序列问题。

在 wiggleMaxLength 函数中，首先检查数组 nums 的大小，如果小于等于1，那么摆动长度就是数组的长度。然后，使用两个变量 curDiff 和 preDiff 分别记录当前元素与下一个元素的差以及前一次计算的差。变量 result 用于记录整个序列中摆动的个数。循环遍历数组，计算相邻元素的差 curDiff。如果当前差异 curDiff 与前一个差异 preDiff 异号，这意味着我们找到了一个摆动，因此将 result 加一，并更新 preDiff 为当前的 curDiff。这种方法可以有效地计算出给定数组中摆动的最大长度。最终，函数返回 result，即整个数组中摆动的个数。

3.实现代码

#include <iostream>
#include <vector>
using namespace std;

class Solution {
public:
    // wiggleMaxLength 函数用于计算摆动序列的最大长度
    int wiggleMaxLength(vector<int>& nums) {
        // 如果数组长度小于等于1，摆动序列的最大长度就是数组的长度
        if (nums.size() <= 1) return nums.size();

        int curDiff = 0; // 当前差异，用于存储当前元素与前一个元素的差值
        int preDiff = 0; // 前一个差异，用于存储上一次计算的当前差异
        int result = 1;  // 结果，用于记录摆动序列的最大长度，初始值为1（至少包含一个数）

        // 遍历数组，从第一个元素开始到倒数第二个元素
        for (int i = 0; i < nums.size() - 1; i++) {
            curDiff = nums[i + 1] - nums[i];// 计算当前元素与下一个元素的差值

            // 检查当前差异与前一个差异是否相反
            // 如果前一个差异非正（即等于0或负数）而当前差异为正，或者
            // 如果前一个差异非负（即等于0或正数）而当前差异为负，则表示发生了摆动
            if ((preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)) {
                result++; // 如果发生了摆动，则摆动序列的长度增加
                preDiff = curDiff;// 更新 preDiff 为当前的 curDiff，用于下一次迭代的比较
            }
        }
        return result;// 返回摆动序列的最大长度
    }
};

//测试
int main()
{
    Solution p;
    vector<int> nums = { 1,7,4,9,2,5 };
    int result = p.wiggleMaxLength(nums);
    cout << "摆动序列的最大长度:" << result << endl;
    cout << endl;
    return 0;
}

 

 

三、最大子数组和

1.题目

Leetcode：第 53 题

给你一个整数数组 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

2.解题思路

使用贪心算法解决最大子数组和问题。

（1）一般算法。
（2）贪心算法：在 maxSubArray 函数中，我们使用变量 result 来跟踪遍历过程中发现的最大子序和，初始值为 INT32_MIN。变量 count 用于计算从数组开始到当前索引的连续子数组的和。循环遍历数组 nums，我们将每个元素依次加到 count 上。如果 count 大于 result，则更新 result。如果 count 小于或等于 0，我们将 count 重置为 0，因为这表示当前的子数组和不会对后续子数组和产生贡献，我们从下一个元素开始计算新的子数组和。这种方法利用了贪心算法的思想，即在每一步选择中，都做出在当前状态下最好选择，从而希望导致结果是全局最优的。
最终，函数返回 result，即整个数组中连续子数组的最大和。

3.实现代码

#include <iostream>
#include <vector>
using namespace std;

// 一、最大子序和（暴力法）
class Solution1 {
public:
    // maxSubArray 函数用于计算（不连续）子数组的最大和
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN; // 初始化结果为整数的最小值
        int count = 0; // 初始化计数器，用于计算子数组的和

        // 遍历数组，从每个元素开始
        for (int i = 0; i < nums.size(); i++) {
            // 这里应该从 i 开始一个新的子数组
            count = 0; // 重置计数器
            // 从当前位置 i 开始，遍历到数组末尾
            for (int j = i; j < nums.size(); j++) {
                count += nums[j];// 将当前元素 nums[j] 加到子数组的和中
                result = count > result ? count : result;// 更新结果为当前子数组的和和已知最大和中的较大者
            }
        }
        return result; // 返回计算得到的最大和
    }
};

// 二、最大子序和（贪心算法）
class Solution2 {
public:
    // maxSubArray 函数用于计算连续子数组的最大和
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN; // 初始化结果为整数的最小值，用于记录最大子序和
        int count = 0; // 初始化计数器，用于计算当前子数组的和

        // 遍历数组中的每个元素
        for (int i = 0; i < nums.size(); i++) {
            count += nums[i];// 将当前元素的值加到 count 上，count 表示从索引 0 开始到当前索引的连续子数组的和
            // 如果当前子数组的和大于已知的最大子序和，则更新最大子序和
            if (count > result) {
                result = count;
            }
            // 如果当前子数组的和小于等于0，则重置 count 为 0，因为任何负数或零都会拉低后续子数组的和
            // 这相当于我们在遇到负数或零时，从下一个元素开始计算新的子数组和
            if (count <= 0) {
                count = 0;
            }
        }
        return result;// 返回计算得到的最大子序和
    }
};

//测试
int main()
{
    Solution2 p;
    vector<int> nums = { -2,1,-3,4,-1,2,1,-5,4 };
    int result = p.maxSubArray(nums);
    cout << "最大子序和:" << result << endl;
    cout << endl;
    return 0;
}

 

 

ps：以上皆是本人在探索算法旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。