什么是贪心算法:
每次拿最大的就是局部最优,最后拿走最大数额的钱就是推出全局最优。
贪心算法一般分为如下四步:
- 将问题分解为若干个子问题
- 找出适合的贪心策略
- 求解每一个子问题的最优解
- 将局部最优解堆叠成全局最优解
455.分发饼干
假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。
对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j] 。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。
这里的局部最优就是大饼干喂给胃口大的,充分利用饼干尺寸喂饱一个,全局最优就是喂饱尽可能多的小孩。
可以尝试使用贪心策略,先将饼干数组和小孩数组排序。然后从后向前遍历小孩数组,用大饼干优先满足胃口大的,并统计满足小孩数量。
另一种方法是:用小饼干满足胃口小的。
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(), g.end());//胃口
sort(s.begin(), s.end());//饼干
int index = s.size()-1;
int result = 0;
for(int i=g.size()-1; i>=0; i--){//
if(index>=0&&s[index]>=g[i]){
result++;
index--;
}
}
return result;
}
};
- 时间复杂度:O(nlogn)
- 空间复杂度:O(1)
为什么时间复杂度是这个?searching for an element in a sorted list of length n is O(nlogn).
376. 摆动序列
如果连续数字之间的差严格地在正数和负数之间交替,则数字序列称为摆动序列。
例如, [1,7,4,9,2,5] 是一个摆动序列,因为差值 (6,-3,5,-7,3) 是正负交替出现的。
给定一个整数序列,返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些(也可以不删除)元素来获得子序列,剩下的元素保持其原始顺序。
考察的是贪心算法。
局部最优:删除单调坡度上的节点(不包括单调坡度两端的节点),那么这个坡度就可以有两个局部峰值。
整体最优:整个序列有最多的局部峰值,从而达到最长摆动序列。
实际操作上,其实连删除的操作都不用做,因为题目要求的是最长摆动子序列的长度,所以只需要统计数组的峰值数量就可以了(相当于是删除单一坡度上的节点,然后统计长度)
这就是贪心所贪的地方,让峰值尽可能的保持峰值,然后删除单一坡度上的节点。
我们用preDiff和curDiff来计算i点的前和后序,为了防止有平坡的出现,我们记录峰值的条件应该是:(preDiff <= 0 && curDiff > 0) || (preDiff >= 0 && curDiff < 0)
为了考虑只有两个数字的数列,我们可以在第一个数字之前加一个它相同的数字,组成平坡。
但还有一种情况需要考虑,那就是单调坡度有平坡。
我们只需要在 这个坡度 摆动变化的时候,更新 prediff 就行,这样 prediff 在 单调区间有平坡的时候 就不会发生变化,造成我们的误判。
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if (nums.size() <= 1) return nums.size();
nums.insert(nums.begin(), nums.front());
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;//只需要在 这个坡度 摆动变化的时候,更新 prediff 就行
}
}
return result;
}
};
- 时间复杂度:O(n)
- 空间复杂度:O(1)
考虑用动态规划的思想来解决这个问题:
class Solution{
public:
int dp[1005][2];
int wiggleMaxLength(vector<int>& nums) {
memset(dp, 0, sizeof(dp));
dp[0][1] = dp[0][0] = 1;
for(int i=1;i<nums.size(); i++){
dp[i][0] = dp[i][1] =1;
for(int j=0;j<i;j++){
if(nums[j]>nums[i]) dp[i][1]=max(dp[i][1], dp[j][0]+1);
}
for(int j=0;j<i;j++){
if(nums[j]<nums[i]) dp[i][0]=max(dp[i][0], dp[j][1]+1);
}
}
return max(dp[nums.size()-1][0], dp[nums.size()-1][1]);
}
};
53. 最大子序和
给定一个整数数组 nums ,找到一个具有最大和的连续子数组(子数组最少包含一个元素),返回其最大和。
输入: [-2,1,-3,4,-1,2,1,-5,4]; 输出: 6; 解释: 连续子数组 [4,-1,2,1] 的和最大,为 6。
局部最优:当前“连续和”为负数的时候立刻放弃,从下一个元素重新计算“连续和”,因为负数加上下一个元素 “连续和”只会越来越小。
全局最优:选取最大“连续和”。
遍历 nums,从头开始用 count 累积,如果 count 一旦加上 nums[i]变为负数,那么就应该从 nums[i+1]开始从 0 累积 count 了,因为已经变为负数的 count,只会拖累总和。
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int i=0;
int res=INT32_MIN;
int len =1;
int sum=0;
for(;i<nums.size();i++){
sum+=nums[i];
if(sum>res){
res = sum;
}
if(sum<=0) sum=0;
}
return res==INT32_MIN?nums[0]:res;
}
};
- 时间复杂度:O(n)
- 空间复杂度:O(1)