Day 31 | 455. 分发饼干 & 376. 摆动序列 & 53. 最大子数组和

455. 分发饼干

 贪心算法：让小饼干喂饱小胃口（从前遍历）

        首先对数组进行排序。s，g都从0开始一直向后遍历，满足要求了count++，否则饼干向后移动一位，直到饼干分完/孩子吃完（有一个数组遍历到末尾）。

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

376. 摆动序列 

其实我没看懂这为啥是贪心。。咋贪心了。。看好多说是动态规划

本题的难点是遇到非波动序列时如何处理后面的元素？

        我一开始想的是移动元素，然后一头雾水，但看了题解后发现题目其实不需要移除元素，只需要返回序列长度即可，因此当遇到非波动序列，一直向后遍历，中间的递增/递减单调区间元素不需要理会，只需要一直向后遍历，让数值越来越大/小，峰值尽可能的保持峰值，即一直向后遍历到峰值即可。

        定义curDiff和preDiff（通过比较其符号是否相等判断波动），preDiff可以等于0（第一步时pre初始化为0）。当pre和cur符号不相等时count++，否则i++直至峰值，若符号再次不相等count++。直至到遍历结束。

贪心算法：

    public int wiggleMaxLength(int[] nums) {
        int count = 1;
        if (nums.length == 1) {
            return nums.length;
        }
        int cur = 0;
        int pre = 0;
        for (int i = 1; i < nums.length; i++) {
            cur = nums[i] - nums[i - 1];
            if ((cur > 0 && pre <=0) || (cur < 0 && pre >=0)) {
                pre = cur;
                count++;
            }
        }
        return count;
    }

53. 最大子数组和

贪心解题思路：     

        定义sum记录每次累加的结果，res代表最终结果，若累加结果sum大于res，则更新res值为sum。

本题难点：当遇到负数时，如何判断是否加入该数字？

         当加入该数后，sum值小于0，后面再加只会越加越小，因此直接令sum=0，从下一个开始重新累加。

    public int maxSubArray(int[] nums) {
        if(nums.length==1){return nums[0];}
        int res=Integer.MIN_VALUE;
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
            if(sum>res){
                res=sum;
            }
            if(sum<0){sum=0;}

        }
        return res;
    }