力扣---贪心算法

455.分发饼干

为了满足更多的小孩，就不要造成饼干尺寸的浪费。

大尺寸的饼干既可以满足胃口大的孩子也可以满足胃口小的孩子，那么就应该优先满足胃口大的。

这里的局部最优就是大饼干喂给胃口大的，充分利用饼干尺寸喂饱一个，全局最优就是喂饱尽可能多的小孩。

可以尝试使用贪心策略，先将饼干数组和小孩数组排序。

然后从后向前遍历小孩数组，用大饼干优先满足胃口大的，并统计满足小孩数量。

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

376. 摆动序列

局部最优：删除单调坡度上的节点（不包括单调坡度两端的节点），那么这个坡度就可以有两个局部峰值。

整体最优：整个序列有最多的局部峰值，从而达到最长摆动序列。

局部最优推出全局最优，并举不出反例，那么试试贪心！

（为方便表述，以下说的峰值都是指局部峰值）

实际操作上，其实连删除的操作都不用做，因为题目要求的是最长摆动子序列的长度，所以只需要统计数组的峰值数量就可以了（相当于是删除单一坡度上的节点，然后统计长度）

这就是贪心所贪的地方，让峰值尽可能的保持峰值，然后删除单一坡度上的节点

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

53. 最大子序和

class Solution {
    public int maxSubArray(int[] nums) {
        int result=0;
        int max=Integer.MIN_VALUE;
        for(int i=0;i<nums.length;i++){
            result+=nums[i];
            max=Math.max(max,result);
            if(result<0){
                result=0;
            }
        }
        return max;
    }
}

122.买卖股票的最佳时机 II

class Solution {
    public int maxProfit(int[] prices) {
        int result=0;
        for(int i=1;i<prices.length;i++){
            result+=Math.max(prices[i]-prices[i-1],0);
        }
        return result;
    }
}

55. 跳跃游戏

class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length==1){
            return true;
        }
        int cover=0;
        for(int i=0;i<=cover;i++){
            cover=Math.max(nums[i]+i,cover);
            if(cover>=nums.length-1){
                return true;
            }
        }
        return false;
    }
}

45.跳跃游戏 II

class Solution {
    public int jump(int[] nums) {
        if(nums==null||nums.length==0||nums.length==1){
            return 0;
        }
        int curDistance=0;
        int maxDistance=0;
        int count=0;
        for(int i=0;i<nums.length;i++){
            maxDistance=Math.max(nums[i]+i,maxDistance);
            if(maxDistance>=nums.length-1){
                 return ++count;
            }
            if(i==curDistance){
                curDistance=maxDistance;
                count++;
            }
        }
        return count;
    }
}