Leetcode算法训练日记 | day31

专题九  贪心算法

一、分发饼干

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

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