代码随想录算法训练营二十三天|贪心part01

最新推荐文章于 2025-08-22 19:21:44 发布

花开富贵ii

最新推荐文章于 2025-08-22 19:21:44 发布

阅读量1.2k

点赞数 24

CC 4.0 BY-SA版权

分类专栏：贪心文章标签：算法 java leetcode 数据结构贪心算法

本文链接：https://blog.csdn.net/2301_80148658/article/details/149538525

贪心专栏收录该内容

5 篇文章

订阅专栏

LeetCode 455 分发饼干

题目链接：455. 分发饼干 - 力扣（LeetCode）

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

对每个孩子 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。

贪心策略：先将饼干和小孩数组按从小到大排序，然后从后向前遍历小孩数组，优先使用尺寸大的饼干满足胃口大的小孩。

代码实现：

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

LeetCode 376 摆动序列

题目链接：376. 摆动序列 - 力扣（LeetCode）

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

例如， [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

要想删除元素使其达到最大摆动序列，应该删除什么元素呢？

以示例二为例：

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

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

在计算是否有峰值的时候，遍历下标i，计算a=nums[i]-nums[i-1]和b=nums[i+1]-nums[i]，如果a>0&&b<0或a<0&&b>0就说明有峰值需要统计。

但需要注意一下三种情况：

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

1.上下坡中有平坡：

举个例子：

它的摇摆序列长度是3，也就是我们在删除的时候，要么删除左边的三个2，要么删除右边的三个2。统一规则，删除左边的三个2。

当i指向第一个2时，a>0&&b=0，当i指向最后一个2时，a=0&&b<0。所以当a=0&&b<0时也要记录一个峰值。所以记录峰值的条件应该是：a>=0&&b<0或a<=0&&b>0。

2.数组首尾两端：

假设数组长度为2，但是计算a和b的时候，至少先不要三个数字才能计算，一种方法我们可以直接写死，就是如果数组长度为2且元素不同，直接返回2；如果不写死的话，就要和我们判断的规则结合在一起。

之前在讨论上下坡中有平坡的情况时，我们知道相同数字连续时，a=0，b>0或<0也要记录峰值。

所以我们可以假设，数组最前面还有一个数字，和数组第一个元素数值相同，这样它就有了坡度即a=0。

count初始为1（默认最右面有一个峰值）。

所以经过以上分析，可以写出如下代码：

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

但是提交了之后，发现还是不对，是因为还有一种情况没有讨论。

3.单调坡中有平坡：

举个例子：（图中的prediff就是我说的a，curdiff就是我说的b）

这种情况，最长波动序列长度是2，但是按照之前的算法算出来的是3，这是因为单调坡的平坡不能算是峰值。

之所以之前的算法不对，是因为我们实时更新了a，但其实我们只需要在坡度摆动变化的时候去更新a，这样a在单调区间有平坡的时候就不会发生变化，造成误判。

所以最终代码为：

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

LeetCode 53 最大子数组和

题目链接：53. 最大子数组和 - 力扣（LeetCode）

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。
示例 2：

输入：nums = [1]
输出：1
示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

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

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

遍历nums，从头开始用count累加，如果count加上nums[i]变为负数，那么count清零；如果没有变为负数，不断更新最大“连续和”。

代码如下：

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