代码随想录算法训练营第31天 455.分发饼干 376. 摆动序列 53. 最大子序和-优快云博客

455.分发饼干

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int child = 0;
        int cookie = 0;

        while(child < g.length && cookie < s.length){
            if(g[child] <= s[cookie]){
                child++;
            }
            cookie++;
        }

        return child;
    }
}

首先，将孩子的胃口数组 g 和饼干尺寸数组 s 进行排序。然后，使用两个指针 child 和 cookie 分别遍历 g 和 s。每次迭代中，如果当前饼干可以满足当前孩子的胃口（即 g[child] <= s[cookie]），则 child 指针向前移动一位。无论当前饼干是否满足当前孩子的胃口，cookie 指针总是向前移动一位。当 g 或 s 的任一数组被完全遍历后，返回 child 指针的位置，这就是最多可以满足的孩子数。

376. 摆动序列

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length < 2){
            return nums.length;
        }

        int prevDiff = nums[1] - nums[0];

        int count = prevDiff != 0 ? 2:1;
        
        for(int i = 2; i <nums.length; i++){
            int diff = nums[i] - nums[i-1];

            if((diff > 0 && prevDiff <= 0) || (diff < 0 && prevDiff >= 0)){
                count++;
                prevDiff = diff;
            }
        }
        return count;
    }
}

如果第一个元素和第二个元素相等（即 prevDiff 等于0），则摆动序列的长度从1开始。如果它们不等（即摆动开始），则摆动序列的长度从2开始。

如果 prevDiff != 0，那么 count 被初始化为2，因为前两个元素构成了摆动序列的开始。
如果 prevDiff == 0，那么 count 被初始化为1，因为第一个元素是摆动序列的开始，但由于第二个元素与第一个元素相等，因此不会增加摆动序列的长度。

这种三元运算符的用法是一种简洁的方式来进行此类条件初始化。

先检查输入数组的长度。如果长度小于2，则返回数组的长度，因为短于2的序列总是摆动序列。然后，代码初始化前一个差异（prevDiff）并根据前两个元素的差异初始化计数。之后，代码遍历数组的其余部分，并在遇到摆动（即，当前差异与前一个差异的符号不同）时增加计数。最后，返回计数作为结果。

53. 最大子数组和

class Solution {
    public int maxSubArray(int[] nums) {
        //   初始化当前最大子数组和为第一个元素
        int currentMax = nums[0];
        //  初始化全局最大子数组和为第一个元素
        int globalMax = nums[0];

        // 从第二个元素开始遍历数组
        for(int i = 1; i < nums.length; i++){
            // 更新当前最大子数组和 它要呢是当前元素本身 要么是当前元素加上前一个最大子数组的和
            currentMax = Math.max(nums[i], currentMax + nums[i]);
            // 将当前最大子数组和与全局最大子数组和进行比较 更新全局最大子数组和
            globalMax = Math.max(globalMax, currentMax);
        }

        // 返回全局最大子数组和 这是整个数组的最大链接子数组和
        return globalMax;
    }
}

著名的 Kadane 算法来解决这个问题。该算法的基本思想是在每个步骤中保持两个变量：当前最大子数组和以及全局最大子数组和。