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

455.分发饼干

想一下，本题的贪心贪在哪里？题目描述是每个孩子最多分一块饼干，目标是尽可能满足数量多的孩子。满足的孩子的数量是不是等于发放饼干的数量？那本题是不是也可以描述为怎样才能发放数量最多的饼干？一个很容易想到的思路就是尽量把小饼干分给胃口小的孩子，大饼干尽量分给胃口大的孩子，避免“浪费”。

1.饼干大小和孩子胃口大小排序，优先把小饼干分给胃口小的孩子。

class Solution {
public: //胃口和饼干尺寸都按照从小到大排序，依次匹配
    int findContentChildren(vector<int>& g, vector<int>& s) {
        sort(s.begin(), s.end());
        sort(g.begin(), g.end());
        int result = 0, i = 0, j = 0;
        while (i < g.size() && j < s.size()) {
            if (s[j] >= g[i]) {
                result++;
                i++;
                j++;
            } else {
                j++;
            }
        }
        return result;
    }
};

2.饼干大小和孩子胃口大小排序，优先把大饼干分给胃口大的孩子。

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.看到题目我的第一想法是统计差值序列正负交替的个数，最后结果+1就是摆动序列最长子序列的长度。感觉并不难，但是修改了几次代码都没有通过，模拟没通过的测试用例才发现问题。因为正负交替的逻辑是diffenence[j]*diffenence[j+1]<0，例如差值序列(2,-3,-2,4)，-3乘以-2是>0的，不符合正负交替逻辑，所以我们后移。-2乘以4<0,是差值序列，所以我们最后得到的差值序列是(2,-3,4)这样也是符合要求的，因为这里面-3乘以-2>0我们后移差值序列-2和-3符号是相同的，所以4和-2异号等价于4和-3异号。以上是理想情况，实际上差值可能为0。例如差值序列(2,-3,0,4)，-3乘以0=0不满足异号条件，我们后移差值序列0乘以4=0也不满足异号条件。这样-3就会认为后面都是和它同号的数了，于是得到差值序列(2,-3)，但实际上的差值序列应该为(2,-3,4)。究其原因是差值0导致了这种差异，那么能不能去掉0呢？答案是可以的，去掉0就相当于原序列中有多个连续相同的值只保留一个，这样并不影响差值序列个数的统计。（注意差值序列全为0的特殊情况处理）

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if(nums.size()==1) return 1;//剪枝
        vector<int> diffenence;//统计非0差值
        for(int i=1;i<nums.size();i++){
            if(nums[i]!=nums[i-1])
            diffenence.push_back(nums[i]-nums[i-1]);
        }
        if(diffenence.size()==0) return 1;//剪枝
        int result=1,j=0;//统计交替出现差值个数
        while(j+1<diffenence.size()){
            if(diffenence[j]*diffenence[j+1]<0){
                result++;
                j++;
            }
            else{
                j++;
            }
        }
        return result+1;//交替差值个数+1就是序列个数
    }
};

2.将摆动序列抽象为峰，判断峰的个数。（注意峰的判断逻辑，还是不容易想的，详情看代码随想录的讲解）

class Solution {
public:
    int wiggleMaxLength(vector<int>& nums) {
        if (nums.size() == 1)
            return 1;
        //前一对差值、当前一对差值、初始峰个数
        int preDiff = 0, curDiff = 0, result = 1;
        for (int i = 1; i < nums.size(); i++) {
            curDiff = nums[i] - nums[i - 1];
            //判峰条件
            if ((preDiff <= 0 && curDiff > 0) ||
                (preDiff >= 0 && curDiff < 0)) {
                result++;
                preDiff = curDiff; // 注意这里，只在摆动变化的时候更新prediff
            }
        }
        return result;
    }
};

53. 最大子序和

1.最朴素的思想就是暴力法，两层for循环，把所有的连续子数组之和都计算一遍。不出意外地超时了，7个测试用例没过，考虑到是自己写的代码，所以还是放上来。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result=INT_MIN;
        for(int i=0;i<nums.size();i++){
            int count=0;
            for(int j=i;j<nums.size();j++){
                count+=nums[j];
                result=count>result?count:result;
            }
        }
        return result;
    }
};

2.自己想的贪心，用sum统计当前连续子数组之和，max统计出现过的连续子数组之和的最大值。当sum<0，说明这个连续子数组之和已经不可能是最大值。因为继续连续sum<0相对于之后的数组是个拖累，所以从下一个数重新开始统计连续子数组。至于之前该连续数组在增长的过程中，最大值已经被max记录过了。（特殊处理一下全是负数的情况，需要排序这也是算法效率不高的原因，不特殊处理修改一下算法也行，我太懒了就不贴了……）

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        vector<int> nums1 = nums;         //复制数组
        sort(nums1.begin(), nums1.end()); //排序
        if (nums1[nums1.size() - 1] <= 0) //最大值都<=0,直接返回最大值
            return nums1[nums1.size() - 1];
        int sum = 0, max = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            if (sum < 0)
                sum = 0; //子数组之和<0就开始找新的连续子数组
            else {
                max = sum > max ? sum : max; //用max记录连续子数组之和的最大值
            }
        }
        return max;
    }
};

3.看了随想录的题解，发现自己的代码还是不够简洁。count统计当前子序列之和，result统计最大值。并把result初始化为nums[0]（全是负数的情况也不需要特殊处理），当前子序列之和>result，就更新最大值，count<=0说明会拉低总和，重新统计子序列之和。

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int result = nums[0], count = 0;
        for (int i = 0; i < nums.size(); i++) {
            count += nums[i];
            // 取区间累计的最大值（相当于不断确定最大子序终止位置）
            if (count > result)
                result = count;
            // 相当于重置最大子序起始位置，因为遇到负数一定是拉低总和
            if (count <= 0)
                count = 0;
        }
        return result;
    }
};

今日总结：贪心，启动！