代码随想录Day34

455.分发饼干

题目：455. 分发饼干 - 力扣（LeetCode）

思路：感觉就是把饼干数组统计到map里面，遍历胃口数组，不断“拿出”map里面满足胃口的饼干，每满足一个，就计数一次，有一个问题就是，我要每次拿出最大的饼干出来，或许应该对两个数组进行排序，然后从尾部开始遍历，直到饼干数组被用光

尝试

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        for(int i = s.size() -1; i >= 0;i--){
            for(int j = g.size() - 1; j > 0; j--){
                if()
            }
        }
    }
}

答案

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int start = 0;
        int count = 0;
        for(int i =0; i < s.length && start < g.length ;i++){
            if(s[i] >= g[start]){
                start++;
                count++;
            }
        }
        return count;
    }
}

小结

• 本质上感觉是双指针
• 可以从小饼干开始，优先满足小胃口，也可以从大饼干开始，优先满足大胃口

376.摆动序列

题目：376. 摆动序列 - 力扣（LeetCode）

思路：我的想法是，不断求差值，判断正负，只有差值正负交替的情况才计数，这样通过双指针遍历数组之后，就得到了子序列的长度，判断正负交替是关键

尝试（部分AC）

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int count = 0;
        if(nums.length == 1) return 1;
        for(int i = 0; i < nums.length -2;i++){
            int gap = nums[i+1] - nums[i];
            int nextgap = nums[i+2] - nums[i+1];
            if(gap>0 && nextgap<0 || gap <0 && nextgap >0){
                count++;
            } 
        }
        return count+2;
    }
}

答案

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        //当前差值
        int curDiff = 0;
        //上一个差值
        int preDiff = 0;
        int count = 1;
        for (int i = 1; i < nums.length; i++) {
            //得到当前差值
            curDiff = nums[i] - nums[i - 1];
            //如果当前差值和上一个差值为一正一负
            //等于0的情况表示初始时的preDiff
            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
                count++;
                preDiff = curDiff;
            }
        }
        return count;
    }
}

小结

• 要考虑到平坡的情况，比如【1，2，2，2，1】所以循环判断时，要把preDiff=0的情况记录下来
• 我想的是【nums[i+1] - nums[i]】来做差，这样会越界，卡尔直接从【nums[1]】开始遍历，计算差值使用【nums[i]  - nums[i-1]】这样的方式会好很多
• 卡尔的答案中，对比差值是需要三个元素的，为了兼容【1，2】这样的测试用例，result 初始为 1（默认最右面有一个峰值），

53.最大子数组和

题目：53. 最大子数组和 - 力扣（LeetCode）

思路：滑动窗口，把所有正数都囊括进来，我想到的是双指针，但是不知道怎么移动起始指针，没有思路

答案

class Solution {
    public int maxSubArray(int[] nums) {
        int maxValue = Integer.MIN_VALUE;
        int count = 0;
        for(int i =0; i< nums.length; i++){
            count+=nums[i];
            if(count > maxValue) maxValue = count;
            if(count < 0) count = 0;
        }
        return maxValue;
    }
}

小结

• 关键是【连续和】为负数时，就重新定义起始指针，而不是遇到负数就跳过
• 重新计数的操作，通过【 if(count < 0) count = 0;】来实现