24暑假算法刷题 | Day28 | 贪心算法 II | LeetCode 122. 买卖股票的最佳时机 II，55. 跳跃游戏，45. 跳跃游戏 II，1005. K次取反后最大化的数组

---

122. 买卖股票的最佳时机 II

点此跳转题目链接

——这题的贪心用得太优雅了，记录一下。

题目描述

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。

返回 你能获得的 最大 利润 。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
     总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
     总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

• 1 <= prices.length <= 3 * 1e4
• 0 <= prices[i] <= 1e4

思路分析

首先不难想到，这题可以用贪心算法，即 “尽可能低价买入，尽可能高价卖出” 。但受限于题目中任何时候最多只能持有一股的限制，这样把prices整体考虑不好操作。

但其实我们可以把prices分成每日的利润来看，就可以轻松使用贪心算法了！

• 考虑在第1天买入、第3天卖出：

• 这次交易的利润为：prices[3] - prices[1]

  而上式可以写成：(prices[3] - prices[2]) + (prices[2] - prices[1])，这就把它分成了两天的日利润之和，此处第i天的日利润可以自然地定义为prices[i] - prices[i - 1]

• 那么以题目描述中的示例1为例，有：

  prices	7	1	5	3	6	4
  日利润	/	-6	4	-2	3	-2

  注意第一天不存在日利润。

  采用贪心思想，把日利润为正的累加：4 + 3 = 7，就是最大利润了！

这样写出的代码也是相当简洁的：

int maxProfit(vector<int> &prices)
{
    int profit = 0;
    for (int i = 1; i < prices.size(); i++){
        if (prices[i] - prices[i - 1] > 0)
            profit += prices[i] - prices[i - 1];
    }
    return profit;
}

---

55. 跳跃游戏

点此跳转题目链接

题目描述

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

输入：nums = [3,2,1,0,4]
输出：false
解释：无论怎样，总会到达下标为 3 的位置。但该下标的最大跳跃长度是 0 ， 所以永远不可能到达最后一个下标。

提示：

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 105

题解

贪心算法解决。

对于某个位置 i ，如果我们能到达这个位置，那么接下来我们最远能跳到 i + nums[i] 处，也可以跳到 i 到 i + nums[i] 之间的位置。所以，如果终点在这一区间之内 （称为该区间 “覆盖” 终点），我们就一定能到达终点。

那么这就要满足一开始的条件： 我们能到达位置 i 。 类似地，到达位置 i ，肯定要先到达之前的某个位置 j : j <= i <= j + nums[j] ，即 j 的区间 “覆盖” i 。所以，我们其实要做的就是，从起点开始不断更新这个 覆盖区间 ，看它最终能否覆盖到终点：

图片来源：代码随想录

实际上，只维护覆盖区间的右边界（能到达的最远距离）即可。如果当前遍历到的下标 i 超过了上一次的覆盖区间右边界，说明已经无法到达位置 i 了，也就没必要往后探索。

代码（C++）

bool canJump(vector<int> &nums)
{
    int farDist = 0; // 维护一个能到达的最远距离farDist
    for (int i = 0; i < nums.size(); ++i)
    {
        if (farDist < i)
            return false;
        farDist = max(farDist, i + nums[i]);
    }
    return true;
}

---

45. 跳跃游戏 II

点此跳转题目链接

题目描述

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处:

• 0 <= j <= nums[i]
• i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例 1:

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

输入: nums = [2,3,0,1,4]
输出: 2

提示:

• 1 <= nums.length <= 104
• 0 <= nums[i] <= 1000
• 题目保证可以到达 nums[n-1]

题解

这题基于 55. 跳跃游戏 ，保证能到达终点，要求最小跳跃次数。和 55题的题解 一样，核心思想仍是采用 “覆盖区间” 来进行探索：

int jump(vector<int> &nums)
{
    int farDist = 0; // 能到达的最远距离
    int cover = 0;   // 当前的覆盖区间（右边界）
    int count = 0;   // 跳跃次数
    for (int i = 0; i < nums.size() - 1; ++i)
    {
        farDist = max(farDist, i + nums[i]);
        if (i >= cover) // 到达当前覆盖的最远距离
        {
            count++;         // 必须再跳一步才能跳出当前覆盖区间
            cover = farDist; // 更新覆盖区间
        }
        if (cover >= nums.size() - 1) // 到达数组末尾
            return count;
    }
    return count;
}

---

1005. K次取反后最大化的数组

点此跳转题目链接

题目描述

给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：

• 选择某个下标 i 并将 nums[i] 替换为 -nums[i] 。

重复这个过程恰好 k 次。可以多次选择同一个下标 i 。

以这种方式修改数组后，返回数组 可能的最大和 。

示例 1：

输入：nums = [4,2,3], k = 1
输出：5
解释：选择下标 1 ，nums 变为 [4,-2,3] 。

示例 2：

输入：nums = [3,-1,0,2], k = 3
输出：6
解释：选择下标 (1, 2, 2) ，nums 变为 [3,1,0,2] 。

示例 3：

输入：nums = [2,-3,-1,5,-4], k = 2
输出：13
解释：选择下标 (1, 4) ，nums 变为 [2,3,-1,5,4] 。

提示：

• 1 <= nums.length <= 104
• -100 <= nums[i] <= 100
• 1 <= k <= 104

题解

典型的贪心算法。很容易想到，要让和最大，就要“贪心”地把原数组中的负数取反，变成正数。然后考虑一些细节问题：

• 如果 k 小于原数组中的负数个数，则应该让最小的k个负数取反，得到的“正收益”自然最大
• 如果 k 大于原数组中的负数个数，意味着将原数组中所有负数（如果有的话）取反后，还“不得不”对已经全是非负数的新数组进行 k' 次取反（ k' 为剩余的取反次数）
  • 如果 k' 为偶数，由于对任何数取反偶数次相当于没变，可以忽略此种情况
  • 如果 k' 为奇数，同上，相当于要对某个数取反1次，自然我们要找此时新数组（全为非负数）中最小的数取反，这样才能将“损耗”降到最低

代码（C++）

int largestSumAfterKNegations(vector<int> &nums, int k)
{
    // 贪心：尽量把小的负数取反，变成正数
    sort(nums.begin(), nums.end(), [](int a, int b){return abs(a) > abs(b);});
    int sum = 0;
    for (int &num : nums) {
        if (num < 0 && k > 0) {
            num = -num;
            k--;
        }
        sum += num;
    }
    if (k % 2 == 1)
        sum -= 2 * nums.back();
    return sum;
}

一开始直接按照绝对值从大到小对原数组排序，这样，负数全取反后，新数组的最后一个数 nums.back() 就是此时的最小值；之后若需要将其取反，就相当于数组和 sum 减去两次该值。