455. 分发饼干、376. 摆动序列、53. 最大子数组和

455.分发饼干

题目描述：

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

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

解答：

法一：base实现

题目要求是尽可能满足孩子的数量最多

如果将大饼干分给胃口小的孩子，那么后面遇到胃口大的孩子就无法满足

因此可以先按照孩子胃口进行排序（便于后边用饼干匹配孩子胃口）

采用贪心算法，每次满足胃口最接近饼干尺寸（<=)的孩子

这样最终可以找到最优解

代码实现：

依次遍历饼干，同时还需要一个函数用于匹配胃口

class Solution {
public:
    //找到最合适的孩子
    int findChild(vector<int>& g, int size){
        int location = -1;
        for (int i = 0; i < g.size(); i++){
            if (g[i] <= size)
                location = i;
            else
                return location;
        }
        return location;
    }
    int findContentChildren(vector<int>& g, vector<int>& s) {
        int child_num = g.size() - 1;
        int fill_num = 0;
        //便于寻找最合适的孩子,可提前跳出循环
        sort(g.begin(), g.end());
        for (int i = 0; i < s.size(); i++){
            int location = findChild(g, s[i]);
            if(location != -1){
                g.erase(g.begin() + location);
                fill_num++;
            }
        }
        return fill_num;
    }
};

法二：一重循环即可

为了满足更多的小孩，就不要造成饼干尺寸的浪费。

大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。

这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

可以尝试使用贪心策略，先将饼干数组和小孩数组排序。

然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。

// 时间复杂度：O(nlogn)
// 空间复杂度：O(1)
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;
    }
};

376.摆动序列

题目描述

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

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

解析：

乍一看，摆动序列+最长子序列，毫无思路。

仔细想想摆动序列，一正一负，就是要求是锯齿状，不满足条件的不要统计，反正本题并不要求返回序列，只要求返回长度，那其实比较简单了，用curDiff和preDiff分别统计差值，再使用一个条件判断即可：

if ((preDiff > 0 && curDiff < 0) || (preDiff < 0 && curDiff > 0))

本题其实难点在于考虑各种各样的边界问题：

（1）只有两个的情况

        可以直接返回2，为方便整合在一起，把初始的result设置为1即可

（2）有平坡的情况

        

 相等的时候不要记录，那修改判断条件为：

if ((preDiff >= 0 && curDiff < 0) || (preDiff <= 0 && curDiff > 0)){

同时这样修改条件也解决了首尾两端的问题

（3）单调有平坡

原来我是每次都会更新preDiff，但在这种情况下，到2-2-3时，明明不符合要求，但是preDiff=0，curDiff>0，错误统计

因此改为符合条件才去更新preDiff

代码实现如下：

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

53. 最大子数组和

题目描述：

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

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

解析：

贪心贪的是哪里呢？

如果 -2 1 在一起，计算起点的时候，一定是从1开始计算，因为负数只会拉低总和，这就是贪心贪的地方！

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

全局最优：选取最大“连续和”

局部最优的情况下，并记录最大的“连续和”，可以推出全局最优。

从代码角度上来讲：遍历nums，从头开始用count累积，如果count一旦加上nums[i]变为负数，那么就应该从nums[i+1]开始从0累积count了，因为已经变为负数的count，只会拖累总和。

这相当于是暴力解法中的不断调整最大子序和区间的起始位置。

那有同学问了，区间终止位置不用调整么？ 如何才能得到最大“连续和”呢？

区间的终止位置，其实就是如果count取到最大值了，及时记录下来了。例如如下代码：

if (count > result) result = count;

这样相当于是用result记录最大子序和区间和（变相的算是调整了终止位置）。

代码实现：

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