2023年4月2日
#贪心的理论基础
大道至简,局部最优推出全局最优,有时候并不需要严格的数学证明,只要有局部最优推全局最优,并且找不到明显的反例,这时候就可以考虑采用贪心算法解决问题。
贪心算法并没有明显的套路,它不像回溯算法那样,有一套具体的代码思路和解题套路,所以第一次过的时候就需要多见,多想,多看。
#分发饼干 Loading Question... - 力扣(LeetCode)
这道题就是贪心的典型应用,由于一个饼干只能给一个人,就是比如我的饼干是6,人的胃口是5,它只会全部给他,并不会说剩1个,所以我只需要从大到小或者从小到大进行“一一满足”,按照这种思路就能解决此问题。
// 版本一
// 时间复杂度:O(nlogn)
// 空间复杂度:O(1)
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;
}
};
下面是从小到大
class Solution {
public:
int findContentChildren(vector<int>& g, vector<int>& s) {
sort(g.begin(),g.end());
sort(s.begin(),s.end());
int index = 0;
for(int i = 0; i < s.size(); i++) { // 饼干
if(index < g.size() && g[index] <= s[i]){ // 胃口
index++;
}
}
return index;
}
};
#摆动序列 Loading Question... - 力扣(LeetCode)
首先,需要知道到底什么样的情况才算摆动,就是前一个数的差分和后一个数的差分是一个正一个负,这样才叫摆动。这时候就出现了第二个问题,相同的数怎么办?即出现“平路”怎么办。很明显“平路”是不算作摆动序列的,这时候又出现了新的两种情况,一种是上--平--下的情况,一种是上--平--上的情况。
对于第一种情况,我们对于平路只需要“保留”最后一个数,无论是只算结果还是删除数字,都只算最后一个,这样得到的结果可以算作是摆动序列。而对于第二种情况,就需要考虑多一步,当我遇到摆动的时候,我再更新我的答案
这道题有点晦涩难懂,建议明天再学一遍。
// 版本二
class Solution {
public:
int wiggleMaxLength(vector<int>& nums) {
if (nums.size() <= 1) return nums.size();
int curDiff = 0; // 当前一对差值
int preDiff = 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;
}
};
#最大子序和 Loading Question... - 力扣(LeetCode)
首先给出的是暴力解法,双for循环,相当于算每个子序列的和,第一个for循环用来控制起点,然后每次循环的时候初始化count,第二个for循环用来记录子序列的和,count+=nums[j]用来记录和,然后不断更新
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int result = INT32_MIN;
int count = 0;
for (int i = 0; i < nums.size(); i++) { // 设置起始位置
count = 0;
for (int j = i; j < nums.size(); j++) { // 每次从起始位置i开始遍历寻找最大值
count += nums[j];
result = count > result ? count : result;
}
}
return result;
}
};
采用贪心算法的话,就是当我的子序列的和<0的话,我直接不要了,从下一个数作为起点重新来计算子序列的和。通过这种方式来不断计算结果,当我的子序列的和<0之后,我直接从下一个作为起点重新开始,这样相当于“剪枝”,能减少循环次数,而且起到了贪心的作用。
我觉得这道题的思路精髓就是这个子序列和<0的思考,自己想的话估计想不到
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int result = INT32_MIN;
int count = 0;
for (int i = 0; i < nums.size(); i++) {
count += nums[i];
if (count > result) { // 取区间累计的最大值(相当于不断确定最大子序终止位置)
result = count;
}
if (count <= 0) count = 0; // 相当于重置最大子序起始位置,因为遇到负数一定是拉低总和
}
return result;
}
};
#买卖股票的最佳时机II 122. 买卖股票的最佳时机 II - 力扣(LeetCode)
今天先不看了,下面的都直接给结果
class Solution {
public:
int maxProfit(vector<int>& prices) {
int result = 0;
for (int i = 1; i < prices.size(); i++) {
result += max(prices[i] - prices[i - 1], 0);
}
return result;
}
};
#跳跃游戏 Loading Question... - 力扣(LeetCode)
class Solution {
public:
bool canJump(vector<int>& nums) {
int cover = 0;
if (nums.size() == 1) return true; // 只有一个元素,就是能达到
for (int i = 0; i <= cover; i++) { // 注意这里是小于等于cover
cover = max(i + nums[i], cover);
if (cover >= nums.size() - 1) return true; // 说明可以覆盖到终点了
}
return false;
}
};
#跳跃游戏II Loading Question... - 力扣(LeetCode)
class Solution {
public:
int jump(vector<int>& nums) {
if (nums.size() == 1) return 0;
int curDistance = 0; // 当前覆盖最远距离下标
int ans = 0; // 记录走的最大步数
int nextDistance = 0; // 下一步覆盖最远距离下标
for (int i = 0; i < nums.size(); i++) {
nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖最远距离下标
if (i == curDistance) { // 遇到当前覆盖最远距离下标
if (curDistance < nums.size() - 1) { // 如果当前覆盖最远距离下标不是终点
ans++; // 需要走下一步
curDistance = nextDistance; // 更新当前覆盖最远距离下标(相当于加油了)
if (nextDistance >= nums.size() - 1) break; // 下一步的覆盖范围已经可以达到终点,结束循环
} else break; // 当前覆盖最远距到达集合终点,不用做ans++操作了,直接结束
}
}
return ans;
}
};