day31｜贪心算法01｜● 理论基础 ● 455.分发饼干 ● 376. 摆动序列 ● 53. 最大子序和

455.分发饼干

思路：
在满足孩子胃口的前提下，尽可能分配小的饼干给到他

1. 胃口太大轮到下一个孩子
   优先考虑胃口，先喂饱大胃口
   局部最优：大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个

如果最大的饼干可以满足肚子最大的孩子，那就给他吃，同时比较下一个。
如果最大的饼干不能满足肚子最大的孩子，那就让他饿着，然后看看能不能满足第二个孩子。（有点黑暗系，放弃小朋友）

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

2. 饼干太小轮到下一个饼干
   优先考虑饼干，小饼干先喂饱小胃口

如果最小的饼干可以满足肚子最小的孩子，那就给他吃，同时比较下一个。
如果最小的饼干不能满足肚子最小的孩子，那就扔掉饼干，看看下一个饼干能不能给他吃。（放弃的是饼干）

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

376. 摆动序列

贪心：
局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。
整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。
尽可能保持峰值，删除单一坡度上的点

三种情况：
情况一：上下坡中有平坡
情况二：数组首尾两端
情况三：单调坡中有平坡

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int preDiff = 0; // 初始化为0
        int currDiff = 0;
        int count = 1; // 默认1，最右边有一个峰值
        for (int i = 0; i < nums.length-1; i++) {
            currDiff = nums[i+1] - nums[i];
            if (preDiff <= 0 && currDiff > 0 || preDiff >= 0 && currDiff < 0) {
                count++;
                preDiff = currDiff; //注意只在摆动的时候才更新pre
            }
        }
        return count;
    }
}

53. 最大子序和

局部最优：当前“连续和”为负数的时候立刻放弃，从下一个元素重新计算“连续和”，因为负数加上下一个元素 “连续和”只会越来越小。

全局最优：选取最大“连续和”

class Solution {
    public int maxSubArray(int[] nums) {
        int result = Integer.MIN_VALUE; // 注意初始化为min value最小负数
        int sum = 0; 
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            result = result > sum ? result : sum; // 取区间累计的最大值（相当于不断确定最大子序终止位置）
            if (sum < 0) {
                sum = 0;
            }
        }
        return result;
    }
}

时间复杂度：O(n)
空间复杂度：O(1)