122. 买卖股票的最佳时机 II
贪心一
画出股票的折线图，将图中折线上升区间相加即是最大利润。
class Solution {
public:
int maxProfit(vector<int>& prices) {
int result = 0;
for (int i = 1; i < prices.size(); i++){
//下降区间直接跳过
if (prices[i] - prices[i - 1] < 0){
continue;
}
//上升区间的利润相加
if (prices[i] - prices[i - 1] > 0){
result += prices[i] - prices[i - 1];
}
}
return result;
}
};贪心二
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;
}
};55. 跳跃游戏
贪心
问题的本质是：跳跃覆盖范围究竟可不可以覆盖到终点！
每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。
贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。
i 每次移动只能在 cover 的范围内移动，每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。
而 cover 每次只取 max(该元素数值补充后的范围, cover 本身范围)。
如果 cover 大于等于了终点下标，直接 return true 就可以了。
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;
}
};45. 跳跃游戏 II
贪心
要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！
这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。
如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。
这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时
- 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。
- 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。
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) { // 遇到当前覆盖最远距离下标
ans++; // 需要走下一步
curDistance = nextDistance; // 更新当前覆盖最远距离下标（相当于加油了）
if (nextDistance >= nums.size() - 1) break; // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
}
}
return ans;
}
};1005. K 次取反后最大化的数组和
贪心一
先将数组从小到大排序，在k次范围内，反转数组中的负数。k = 0后，从新在对数组排序，如果此时剩余的k，k % 2 == 0，直接将数组元素全部相加，k % 2 == 1，将第一个元素翻转， 然后全部元素相加。
class Solution {
public:
int largestSumAfterKNegations(vector<int>& nums, int k) {
int sum = 0;
sort(nums.begin(), nums.end());
for (int i = 0; i < nums.size(); i++) {
//在k次范围内，反转负数
if (nums[i] < 0 && k > 0) {
nums[i] = (-nums[i]);
k--;
}
}
//从新排序数组
sort(nums.begin(), nums.end());
if (k % 2 == 0) {
for (int i = 0; i < nums.size(); i++){
sum += nums[i];
}
}
if (k % 2 == 1) {
sum += (-nums[0]);
for (int i = 1; i < nums.size(); i++){
sum += nums[i];
}
}
return sum;
}
};贪心二
- 第一步：将数组按照绝对值大小从大到小排序，注意要按照绝对值的大小
- 第二步：从前向后遍历，遇到负数将其变为正数，同时K--
- 第三步：如果K还大于0，那么反复转变数值最小的元素，将K用完
- 第四步：求和
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;
}
};
