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

Leetcode 455.分发饼干

题目链接：Leetcode 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)
  (贪心策略：先满足胃口小的)

class Solution {
public:
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(g.begin(), g.end());
        sort(s.begin(), s.end());
        //贪心策略：先满足胃口小的
        int index = 0;
        for (int i = 0; i < s.size(); i++) {            //遍历饼干
            if (index < g.size() && g[index] <= s[i]) { //遍历胃口
                index++;
            }
        }
        return index;
    }
};

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

Leetcode 376. 摆动序列

题目链接： Leetcode 376. 摆动序列
题目描述： 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。子序列可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。
给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。
思路： 这道题我第一反应是利用动态规划解决，因为根据摆动序列定义可以知道，摆动序列的数字是小大小或者大小大这样的山峰山谷状态，因此我们可以利用动态规划拆分子问题，记住过往，减少重复计算这种特点来解决本题。
代码如下：（动态规划）

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        int dp[1010][2];
        //规定dp[i][0]：前i个数，并且第i个数作为山峰的摆动子序列最大长度
        //规定dp[i][1]：前i个数，并且第i个数作为山谷的摆动子序列最大长度
        dp[0][0] = dp[0][1] = 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])//第i个数为山谷，则寻找山峰
                    dp[i][1] = max(dp[i][1], dp[j][0] + 1);
            }
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i])//第i个数为山峰，则寻找山谷
                    dp[i][0] = max(dp[i][0], dp[j][1] + 1);
            }
        }
        int n = nums.size() - 1;
        return max(dp[n][0], dp[n][1]);
    }
};

除了动态规划，我们还可以使用贪心来解决。

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()<1) return nums.size();
        int pre=0;//记录当前数字与前一个数的差值
        int cur=0;//记录当前数字与下一个数的差值
        int result=1;//默认最右侧存在一个摆动序列长度
        for(int i=0;i<nums.size()-1;i++){
            cur=nums[i+1]-nums[i];
            if((pre>=0&&cur<0)||(pre<=0&&cur>0)){
                result++;
                pre=cur;
            }
        }
        return result;
    }
};

Leetcode 53. 最大子数组和

题目链接： Leetcode 53. 最大子数组和
题目描述： 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分。
思路： 本题第一反应可以暴力枚举，时间复杂度O(N^2)看了眼数据范围应该发现会超时，再结合题意：需要寻找和最大的连续子数组，联想到可以使用动态规划来解决。（上道题Leetcode 376. 摆动序列也是根据连续想到的动态规划）
代码如下：（动态规划）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        if (nums.size() == 0)
            return 0;
        vector<int> dp(nums.size(), 0); // dp代表前i个元素对应连续子数组的最大和
        dp[0] = nums[0];
        int result = dp[0];
        for (int i = 1; i < nums.size(); i++) {
            dp[i] = max(dp[i - 1] + nums[i], nums[i]);
            if (dp[i] > result)//更新最大值
                result = dp[i];
        }
        return result;
    }
};

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

本题同样可以使用贪心来做：

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

• 全局最优：选取最大“连续和”
  代码如下：（贪心）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = INT32_MIN;
        int cnt = 0;
        for (int i = 0; i < nums.size(); i++) {
            cnt += nums[i];
            if (cnt > result)//更新最大值
                result = cnt;
            if (cnt <= 0)//只有遇到负数才会让cnt<=0(别漏掉等号),而此时就该重新计算cnt了
                cnt = 0;
        }
        return result;
    }
};

• 时间复杂度：O(n)
• 空间复杂度：O(1)
  总结： 后两道题的两种做法值得琢磨，没想到贪心和动态规划的题型联系这么紧密。（PS：春节放假心有点散了，欠了好几天的题，这几天抓紧补吧）
  最后，如果文章有错误，请在评论区或私信指出，让我们共同进步！