LeetCode刷题笔记--贪心算法

---

算法介绍

贪心算法（又称贪婪算法，Greedy algorithm）是指，在对问题求解时，总是做出在当前看来是最好的选择，就能得到问题的答案。也就是说，不从整体最优上加以考虑，算法得到的是在某种意义上的局部最优解 。

贪心算法不是对所有问题都能得到整体最优解。能使用贪心算法解决的问题具有贪心选择性质。贪心选择性质严格意义上需要数学证明。能使用贪心算法解决的问题必须具备无后效性，即某个状态以前的过程不会影响以后的状态，只与当前状态有关。

---

练习题目

1. 455.分发饼干

题目： 假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。

示例 1:
输入: g = [1,2,3], s = [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。

示例 2:
输入: g = [1,2], s = [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.

求解：
首先对数组 g 和 s 排序，然后从小到大遍历 g 中的每个元素，对于每个元素找到能满足该元素的 s 中的最小的元素。具体而言，令 i 是 g 的下标，j 是 s 的下标，初始时 i 和 j 都为 0，进行如下操作。

对于每个元素 g[i]，找到未被使用的最小的 j 使得 g[i]≤s[j]，则 s[j] 可以满足 g[i]。由于 g 和 s 已经排好序，因此整个过程只需要对数组 g 和 s 各遍历一次。当两个数组之一遍历结束时，说明所有的孩子都被分配到了饼干，或者所有的饼干都已经被分配或被尝试分配（可能有些饼干无法分配给任何孩子），此时被分配到饼干的孩子数量即为可以满足的最多数量。

代码如下：

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        int len_s=s.length;
        int len_g=g.length;
        if(len_s==0 || len_g==0){return 0;}
        //对数组进行排序
        Arrays.sort(g);
        Arrays.sort(s);

        //第一张解法，与解法二复杂度相等
        // int count=0;
        // for(int i=0;i<len_s;i++){
        //     if(count<len_g&&s[i]>=g[count]){
        //         count++;
        //     }
        // }

        //第二种解法
        //记录满足个数
        int count=0;
        //双指针
        for(int i=0,j=0;i<len_g&&j<len_s;i++,j++){
            //判断s数组j位置是否符合要求
            //不符合j指针向后走
            while(j<len_s&&s[j]<g[i]){
                j++;
            }
            //j指针符合要求，计数加一
            if(j<len_s){
                count++;
            }
        }
        return count;
    }
}

2. 376.摆动序列

题目： 如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为 摆动序列 。第一个差（如果存在的话）可能是正数或负数。仅有一个元素或者含两个不等元素的序列也视作摆动序列。

例如， [1, 7, 4, 9, 2, 5] 是一个 摆动序列 ，因为差值 (6, -3, 5, -7, 3) 是正负交替出现的。

相反，[1, 4, 7, 2, 5] 和 [1, 7, 4, 5, 5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
子序列 可以通过从原始序列中删除一些（也可以不删除）元素来获得，剩下的元素保持其原始顺序。

给你一个整数数组 nums ，返回 nums 中作为 摆动序列 的 最长子序列的长度 。

示例 1：
输入：nums = [1,7,4,9,2,5]
输出：6
解释：整个序列均为摆动序列，各元素之间的差值为 (6, -3, 5, -7, 3) 。

示例 2：
输入：nums = [1,17,5,10,13,15,10,5,16,8]
输出：7
解释：这个序列包含几个长度为 7 摆动序列。
其中一个是 [1, 17, 10, 13, 10, 16, 8] ，各元素之间的差值为 (16, -7, 3, -3, 6, -8) 。

示例 3：
输入：nums = [1,2,3,4,5,6,7,8,9]
输出：2

求解：
本题通过不断地交错选择「峰」与「谷」，可以使得该序列尽可能长
我们记录当前序列的上升下降趋势。每次加入一个新元素时，用新的上升下降趋势与之前对比，如果出现了「峰」或「谷」，答案加一，并更新当前序列的上升下降趋势。

代码如下：

class Solution {
    public int wiggleMaxLength(int[] nums) {
        int len=nums.length;
        if(len == 1) {return 1;}
        if((len==2) && (nums[0] != nums[1])) {return 2;}

        int cha = nums[1]-nums[0];
        //头部元素摆动判断
        int res = cha==0 ? 1:2;
        for(int i=2;i<nums.length;i++){
            int cha1=nums[i]-nums[i-1];
            //判断摆动
            if((cha>=0 && cha1<0) || (cha<=0 && cha1>0)){
                res++;
                cha=cha1;
            }
        }
        return res;
    }
}

3. 55.跳跃游戏

题目： 给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：
输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

求解：
思路：
①如果某一个作为起跳点的格子可以跳跃的距离是 3，那么表示后面 3 个格子都可以作为 起跳点；
②可以对每一个能作为起跳点的格子都尝试跳一次，把能跳到最远的距离不断更新；
③如果可以一直跳到最后，就成功了。

代码如下：

class Solution {
    public boolean canJump(int[] nums) {
        int len=nums.length;
        int max=0;
        for(int i=0;i<len;i++){
            //判断能否到达当前索引点
            //不能到达则直接返回，减少空间损耗
            if(max>=i){
                max=Math.max(max,i+nums[i]);
            }else{
                return false;
            }
            //若可以到达最后索引点，返回true
            //若可以到达索引点后的点，
            //同样可以到达最后点位置（示例1跳跃步数不固定）
            if(max>=len-1){
                return true;
            }
        }
        return false;
    }
}

---

总结

以上就是今天要讲的内容，本文仅仅简单介绍了贪心算法及相关例题，该算法无固定模式，还需具体题目具体分析，其核心思想是总是做出在当前看来是最好的选择，可适当增加一些剪枝降低其复杂度。

参考《力扣 贪心算法》
https://leetcode.cn/tag/greedy/problemset/