第28天，贪心算法part02，题目难度在增加，要锻炼贪心思维能力(ง •_•)ง，编程语言：C++
目录
122.买卖股票的最佳时机II
文档讲解：代码随想录买卖股票的最佳时机II
视频讲解：手撕买卖股票的最佳时机II
题目：
学习： 本题最关键的在于理解每天价格之间的关系，事实上从第二天起每一天都会存在利润，只不过有的时候利润是负，有的时候利润是正。因此依据贪心思想，我们收集所有的正利润，得到的就会是最大的利润。不拘泥于选择哪一天买进，而是把每天都作为可能买进，可能卖出的选择，从而收割所有的正利润。
代码：
//时间复杂度O(n)
//空间复杂度O(1)
class Solution {
public:
int maxProfit(vector<int>& prices) {
int result = 0; //统计利润
//贪心思路，每次只收集正利润
for(int i = 1; i < prices.size(); i++) {
//贪心没有套路，只能靠多了解锻炼
int profit = prices[i] - prices[i - 1];
if(profit > 0) {
result += profit;
}
}
return result;
}
};总结：贪心没有套路，只能通过多练习题目，了解更多的题型，提高贪心的思维能力。
55. 跳跃游戏
文档讲解：代码随想录跳跃游戏
视频讲解：手撕跳跃游戏
题目：
学习：本题不能拘泥在每一步怎么跳上，因为跳跃的方法有很多种，如果关注点在跳多少，怎么跳上就会使得需要遍历的情况很多，并且数组一旦长起来，耗费的时间也会指数增加。
本题的关键在于理解并找到能够跳跃的最大长度（最大覆盖范围），从下标为0开始，我们每走一步确定当前能够到达的最大长度（局部最优），直到最大长度大于等于数组的长度说明能够到达终点，或者是我们遍历能够达到的最大长度后，还是没有达到终点则说明不能到达终点（整体最优）。用图来表示为：
下标 i 在cover范围内移动，每次我们找到了更大的cover，就进行更新。
代码：
//时间复杂度O(n)
//空间复杂度O(1)
class Solution {
public:
bool canJump(vector<int>& nums) {
//贪心策略，找到跳跃的最大覆盖范围
int cover = 0; //初始化覆盖范围
for(int i = 0; i <= cover; i++) {
//更新跳跃的最大覆盖范围
cover = max(cover, i + nums[i]);
//说明覆盖到了最后一个节点
if(maxboard >= nums.size() - 1) return true;
}
return false;
}
};45.跳跃游戏II
文档讲解：代码随想录跳跃游戏II
视频讲解：手撕跳跃游戏II
题目：
学习： 本题与上一题不同的地方在于，本题需要统计走的步数，不能单纯的看覆盖的范围大小了，同时本题题干也说明了一定能够到达最后的位置。
但本题依旧需要用到每一步的覆盖范围，不同的在于，本题需要用一个变量记录前一步覆盖的范围，而遍历过程中下标i超过了覆盖范围时，就说明要走下一步了，此时前一步的覆盖范围就变成了当前的最大覆盖范围，之后依次类推直到找到覆盖范围到达最后的节点。用图来表示为：
代码：关键在于：1.如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。2.如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。
//时间复杂度O(n)
//空间复杂度O(1)
class Solution {
public:
int jump(vector<int>& nums) {
if (nums.size() == 1) return 0;
int result = 0; //记录跳跃的步数
int precover = 0; //当前覆盖最远距离下标
int cover = 0; //下一步覆盖最远距离下标
for(int i = 0; i < nums.size(); i++) {
cover = max(cover, i + nums[i]);
if(i == precover) {
result++;
precover = cover;
if (precover >= nums.size() - 1) {
return result;
}
}
}
return result;
}
};总结：本题的贪心依旧十分巧妙，理解本题的关键在于： 以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点，这个范围内最少步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位。
1005.K次取反后最大化的数组和
文档讲解：代码随想录K次取反后最大化的数组和
视频讲解：手撕K次取反后最大化的数组和
题目：
学习：显然本题的贪心想法是很容易能够想到的，本题有两个贪心的部分：1.当数组中存在负数，且k大于0时，我们局部最优就是将绝对值最大的负数进行反转，这样才能够最终得到最大的数组之和。2.当数组中不存在负数后，k还大于0，此时我们局部最优的方式应该是将绝对值最小的正整数（包含0）进行反转，并且只对其进行反转，这样的话如果k为偶数，最后还是只有正整数，如果k为负数，那这个负数也会是绝对值最小的那个，最终就能得到数组和最大。
代码：根据上述贪心逻辑，我们可以写出代码如下，主要注意两点：1.要先对数组进行排序；2.要找到绝对值最小的数，包括从负数变为正数后的那些数。
//时间复杂度O(nlogn)排序算法复杂度
//空间复杂度O(1)
class Solution {
public:
int largestSumAfterKNegations(vector<int>& nums, int k) {
//贪心逻辑，先对负数进行取反（先取反绝对值最小的负数）
//如果k还有剩余，对最小的正数进行取反
sort(nums.begin(), nums.end());
int count = INT_MAX; //记录最小的正数，包括负数变成的正数
int result = 0; //记录最终和
//取反所有负数
for (int i = 0; i < nums.size(); i++) {
if(k > 0 && nums[i] < 0) {
k--;
nums[i] *= -1;
}
count = min(count, nums[i]);
result += nums[i];
}
//如果还有奇数次的k，把最小的正数取反，如果是偶数的k就不用了，因为可以对一个数反复取反
if(k%2 == 1) {
//把最小的正数取反也就意味着减去两倍的count(减去原先的count，再加上负数的count)
result -= count*2;
}
return result;
}
};本题对于排序算法还有可以优化的部分，可以最开始就通过绝对值大小对数组进行排序。最后可以根据以下步骤进行代码编写：
- 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
- 第二步：从前向后遍历，遇到负数将其变为正数，同时K--
- 第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完
- 第四步：求和
代码：
//时间复杂度O(nlogn)
//空间复杂度O(1)
class Solution {
static bool cmp(int a, int b) {
return abs(a) > abs(b);
}
public:
int largestSumAfterKNegations(vector<int>& A, int K) {
sort(A.begin(), A.end(), cmp); // 第一步
for (int i = 0; i < A.size(); i++) { // 第二步
if (A[i] < 0 && K > 0) {
A[i] *= -1;
K--;
}
}
if (K % 2 == 1) A[A.size() - 1] *= -1; // 第三步
int result = 0;
for (int a : A) result += a; // 第四步
return result;
}
};总结：
贪心算法，更多的还是考研一个常识性和思维性的东西，需要多加练习，多加锻炼。