代码随想录第二十七天 | Leecode 455. 分发饼干、 376. 摆动序列、 53. 最大子数组和

Leecode 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。

解题思路与代码展示

本题要求尽可能多得将小孩饼干分发，由于每人只能一块饼干，考虑将每个人的需求量排序，同时将饼干也进行排序。再按照需求量从小到大的顺序来进行分配，这样分配到不能再分配的时候，即完成了所有饼干的分配。

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end()); // 将饼干量和需求量进行排序
        sort(s.begin(), s.end());
        int i = 0;
        int j = 0;
        int result = 0;
        while(i < g.size() && j < s.size()){ // 按照需求顺序分配
            if(g[i] <= s[j++]){ // 如果满足分配条件那就分配
                i++;
                result++;
            }
        }
        return result;
    }
};

Leecode 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

解题思路与代码展示

本题要求序列中单调性反转的次数，需要特别注意的是出现数相同的时候，并没有发生反转，如何处理其中的每种情况需要仔细讨论。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size() <= 1) return nums.size(); // 当数组中的个数小于等于1时的特殊情况
        int result = 1; // 反转的最少次数就是1
        int up = 1; // 初始化up和down变量为1
        int down = 1;
        for(int i = 1; i < nums.size(); i++){ // 遍历所有数组
            if(nums[i] > nums[i-1]) up = down + 1; // 每次两个数只要不相等，那么就说明有可能出现反转。但如果上一次的大小关系和本次一致，会导致up/down的值不变
            if(nums[i] < nums[i-1]) down = up + 1;
        }
        return max(up, down); // 最终的反转次数就是up和down中的最大值
    }
};

使用上面代码可以巧妙地计算出摆动序列的长度。

Leecode 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

解题思路与代码展示

这道题目的解法也是非常巧妙，首先考虑在数组中任取一个子数组，接着考虑在这个子数组左右两侧以外的最近元素，如果这个元素为正，那么将其加入子数组中必然可以使得子数组中的和更大，但如果这个元素为负，单独加入这一个元素会使得子数组之和变小，但说不定在这个负数的旁边还有一个绝对值更大的正数可以继续加入子数组中从而使得数更大。

即根据这个朴素的思想我们可以总结出一个结论：

• 当子数组旁边的元素为正时，要使得子数组元素之和尽可能大，则一定要把这个数添加进去；但如果相邻的元素为负，则不一定要添加。

接下来我们就需要讨论，采用什么样的方法可以判断负数是否需要添加到子数组中。

考虑从数组的最左侧出发进行遍历，遍历过程中将扫过的元素逐个合并，使用子数组和来作为组成新合成的元素。而一旦当前元素的和为负数之后，就认为此时合并完成一个元素，从下一个元素开始求和并进行合并形成另一个新的元素。这种思想的原因在于，如果当前某最左一段子数组的和已经为负。那么说明在其右侧子数组要想最大化，就不会将这部分数组给包括进去。

故我们可以写出下面代码：

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN; // 初始化为int类型中的最小值
        int count = 0; // 当子数组中没有元素时，当前子数组和为0
        for(int i = 0; i < nums.size(); i++){
            count += nums[i]; // 每次都将一个新的数纳入当前子数组中进行合并
            if(count > result) result = count; // 每次都将新的子数组的和与结果进行比较并保留最大值
            if(count <= 0) count = 0; // 如果当前子数组求和为0，那么说明此时往左的这一半子数组都不用再考虑，重置count=0相当于使得子数组为空
        }
        return result;
    }
};

上面代码非常巧妙地解决了最大子数组和的问题。而且时间复杂度为\(O(n)\)。

今日总结

感觉这部分贪心的算法都很难想，难度有点大。另外，最近事情突然多起来了，马上有两场考试，同时还有论文的二审结果下来还需要进行小修，非常非常忙。这边Leecode只能暂时搁置，现在就尽可能每天刷一道保持铺地板吧...

今日Leecode已经95了，尽量在这周破100吧，再接再厉！