代码随想录第二十六天(贪心算法)| 分发饼干 | 摆动序列| 最大子数组和

贪心算法实际上就是怎么做的价值最大，贪心嘛，就是想要更好一点

分发饼干

这一题为了不浪费饼干，每个孩子只能拿一块饼干，不能将大的饼干去喂小胃口的孩子，那样就浪费了，到时候小的饼干又喂不了大胃口的小孩，所以先用大饼干喂大胃口的孩子，满足大胃口的孩子之后，再去喂小胃口的孩子。所以将两个数组先进行排序，之后从后往前遍历，先满足大胃口孩子。

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int len_g=g.length;
        int len_s=s.length;
        Arrays.sort(g);
        Arrays.sort(s);
        int count=0;
        while(len_g>0&&len_s>0){
            if(s[len_s-1]>=g[len_g-1]){
                count++;
                len_g--;
                len_s--;
            }else{
                len_g--;
            }
        }
        return count;
    }
}

摆动序列

这一题又学到了数形结合的重要性，画出示意图比直接对着数组题目看要直观的多。

这题要解决三种情况，一种是首尾的情况，因为它们只有两个元素，要判断摆动点的话需要三个点。二是单调的坡的情况，需要将坡上的点排除掉。三是单调有平坡。因为在解决第一种情况的时候，我们默认首元素前面有个平坡，所以起点算一个摆动点，同时默认尾部是一个摆动点，这个实现是通过给result初始赋值为1。第三种情况通过记录上一个摆动点的prediff坡度和后面遍历的curdiff坡度的关系来解决。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if(nums.length==1){
            return 1;
        }
        int result=1;
        int prediff=0;
        int curdiff=0;
        for(int i=0;i<nums.length-1;i++){
            curdiff=nums[i+1]-nums[i];
            if((prediff>=0&&curdiff<0)||(prediff<=0&&curdiff>0)){
                result++;
                prediff=curdiff;//保证是摆动点，一正一负
            }   
        }
        return result;
    }

}

最大子数组和

这一题最重要的就是要明确在连续子数组和为负数的时候，就跳过之前的元素，选择下一个元素作为子数组的起点，这个操作是通过给子数组和count置零实现的，相当于从下一个元素开始重新计算和。而不是遇到负数就跳过，因为有可能好几个正数之间夹了一个负数。而之前跳过的子数组和也不会直接删除，会用result值记录起来，最后返回一个最大的result值。

class Solution {
    public int maxSubArray(int[] nums) {
        if(nums.length==1){
            return nums[0];
        }
        int count=0;
        int result=Integer.MIN_VALUE;
        for(int i=0;i<nums.length;i++){
            count+=nums[i];
            if(count>result){
                result=count;
            }
            if(count<0){
                count=0; //重新定义子数组和的起点
            }
        }
        return result;

    }
}