代码随想录算法训练营第二十三天|455.分发饼干、376. 摆动序列、53. 最大子序和

什么是贪心算法：

每次拿最大的就是局部最优，最后拿走最大数额的钱就是推出全局最优。

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

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

455.分发饼干

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

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

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

可以尝试使用贪心策略，先将饼干数组和小孩数组排序。然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。

另一种方法是：用小饼干满足胃口小的。

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

• 时间复杂度：O(nlogn)
• 空间复杂度：O(1)

为什么时间复杂度是这个？searching for an element in a sorted list of length n is O(nlogn).

376. 摆动序列

如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。

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

给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。

考察的是贪心算法。

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）

这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点。

我们用preDiff和curDiff来计算i点的前和后序，为了防止有平坡的出现，我们记录峰值的条件应该是：(preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)

为了考虑只有两个数字的数列，我们可以在第一个数字之前加一个它相同的数字，组成平坡。

但还有一种情况需要考虑，那就是单调坡度有平坡。

我们只需要在 这个坡度 摆动变化的时候，更新 prediff 就行，这样 prediff 在 单调区间有平坡的时候 就不会发生变化，造成我们的误判。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() <= 1) return nums.size();
        nums.insert(nums.begin(), nums.front());
        int prediff =0;
        int curdiff =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;//只需要在 这个坡度 摆动变化的时候，更新 prediff 就行
            }    
        }
        return result;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)

考虑用动态规划的思想来解决这个问题:

class Solution{
public:
    int dp[1005][2];
    int wiggleMaxLength(vector<int>& nums) {
        memset(dp, 0, sizeof(dp));
        dp[0][1] = dp[0][0] = 1;
        for(int i=1;i<nums.size(); i++){
            dp[i][0] = dp[i][1] =1;
            for(int j=0;j<i;j++){
                if(nums[j]>nums[i]) dp[i][1]=max(dp[i][1], dp[j][0]+1);
            }
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]) dp[i][0]=max(dp[i][0], dp[j][1]+1);
            }
        }
        return max(dp[nums.size()-1][0], dp[nums.size()-1][1]);
    }
};

53. 最大子序和

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

输入: [-2,1,-3,4,-1,2,1,-5,4]； 输出: 6； 解释:  连续子数组  [4,-1,2,1] 的和最大，为  6。

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

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

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

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

• 时间复杂度：O(n)
• 空间复杂度：O(1)