贪心算法day25| 贪心理论基础、455. 分发饼干、376. 摆动序列、53.最大子数组和
贪心理论基础
- 本质:想清楚 局部最优 是什么,如何推导出全局最优
- 贪心算法并没有固定的套路
- 怎么知道该不该用贪心算法呢?最好用的策略就是举反例,如果想不到反例,那么就试一试贪心吧。
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。
提示:
1 <= g.length <= 3 * 104
0 <= s.length <= 3 * 104
1 <= g[i], s[j] <= 231 - 1
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int result=0;
int index=s.size()-1;
for(int i=g.size()-1;i>=0;i--)
{
if(index>=0&&s[index]>=g[i])
{
result++;
index--;
}
}
return result;
}
};
局部最优:用最大的饼干满足胃口最大的孩子
整体最优:从而满足尽可能多的孩子(优化类问题)
优化类可以尝试取按照贪心的思路来做,由局部到整体
易错点:
if(index>=0&&s[index]>=g[i])
注意index>=0不能漏写,而且必须写在前面!,如果放在&&后面则会出现异常!因为&&的判断是有先后顺序的,先看左边的再看右边的。如果index>=0写在前面,index<0是过不来的;反之,则s[index]中的index是完全有可能出现负值而造成异常,此时index>=0还没来得及判断。
- 这里是if而不是while,因为一个小孩知对应一个饼干
难点:
- 排序,思路是建立在有序的基础上的,所以开始之前需要对两个数组排序
- for循环遍历的是孩子而不是变干,主次关系要分清楚,在for循环内部再判断有没有合适的饼干
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
提示:
1 <= nums.length <= 1000
0 <= nums[i] <= 1000
(自己第一遍做的,失败了但不知道为什么…:
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
vector<int> cha;
for(int i=1;i<nums.size();i++)
{
cha.push_back(nums[i]-nums[i-1]);
}
int result=1;
if(nums.size()==1||nums.size()==2&&nums[0]==nums[1])
result= 1;
else if(nums.size()==2&&nums[0]!=nums[1])
result= 2;
else
{
for(int i=0;i<cha.size();i++)
{
if(i=0&&cha[i]!=0)
result++;
if(i>0&&cha[i]*cha[i-1]<0)
result++;
else
continue;
}
}
return result;
}
};
所以做这题的时候不建议大家用差数组,而是画原数组的摆动图,直接在原数组上操作,这样不容易乱。
正确的解法:
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if(nums.size()<=1)
return nums.size();
int prediff=0;
int curdiff=0;
int result=1;
for(int i=0;i<nums.size()-1;i++)
{
curdiff=nums[i+1]-nums[i];
if(prediff<=0&&curdiff>0||prediff>=0&&curdiff<0)
{
result++;
prediff=curdiff;
}
}
return result;
}
};
虽然代码简短,但是思考的过程还是很复杂的。
难点:
- 要在元素处于峰值的时候result++。问题是,元素的峰值状态该怎么表示?这里我们引入了两个变量:prediff、curdiff,其中curdiff=nums[i+1]-nums[i],表示该元素之后的坡度,那么prediff就表示了元素之前的坡度。prediff的值不是计算得来的,而是直接由上一阶段的curdiff赋值得来的。
- prediff什么时候该被赋值?只有当前一个curdiff有坡度的时候(即curdiff!=0),原因:为了使单调有平坡和摆动有平坡都成立(主要是为了使前者的情况成立)
易错点:
- 最后一个元素,默认峰值,因为它没有curdiff,所以不能代入,只好在初始化的时候就加1即result=1。
- 第一个元素,它没有prediff,因为我们在处理平坡的时候,前面的prediff是可以取0的,所以这时我们只要将prediff初始化为0,即可以非常巧妙地满足条件了
做这道题都是先按已经想到的来做,做完之后发现有问题再考虑是否漏情况了。因为情况很多,第一次很难考虑周全,需要你不断去调整。
这道题与贪心的关系:
局部最优:删除单调坡度上的节点(不包括单调坡度两端的节点),那么这个坡度就可以有两个局部峰值。
整体最优:整个序列有最多的局部峰值,从而达到最长摆动序列。
53. 最大子数组和
给你一个整数数组 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
提示:
1 <= nums.length <= 105
-104 <= nums[i] <= 104
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int result=INT_MIN;
int sum=0;
for(int i=0;i<nums.size();i++)
{
if(sum>0)
sum+=nums[i];
else
sum=nums[i];
if(sum>result)
result=sum;
}
return result;
}
};
本题是很容易错的,需要不断地调整。
核心逻辑:当子序<0时,就将它抛弃,取下一个数为新的起点;当子序和>0时,与下一个数相加,若>result,则改变result值。
易错点:
- 因为sum可能为负值,并且最后返回的result可能就是这个负值,所以reult初始时肯定要比任意的负值小,才能被赋上,所以int result=INT_MIN;