day28 代码随想录 | 贪心 买卖股票 跳跃游戏 K次取反

买卖股票的最佳时机 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 。

这题真的不好想，但是代码是真的简单。

贪心，就是我每次只加正利润，不加负利润

还有就是price[3]-price[0] = price[3] - price[2] + price[2] - price[1] + price[1] - price[0]

我们不要看整体，我们一天一天的看，将利润分解成每天的维度

局部最优就是：收集每天的正利润，全局最优：求得最大利润

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 1:
            return 0
        
        result = 0
        for i in range(1, len(prices):
            profit = prices[i] - prices[i-1]
            if profit > 0:
                result += profit
        return result

55. 跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

这个题怎么用到贪心的思想呢，我们来看最大覆盖范围，如果覆盖范围覆盖了整个数组，就可以

反之不行。我们每次将覆盖范围取最大，然后遍历下一个数组，看是否能够增加覆盖范围，

如果能，那就更新覆盖范围

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        if len(nums) == 1:
            return Tree
        cover = 0
        for i in range(len(nums)):
            if i <= cover: # 在当前覆盖范围内 取更新新的覆盖范围
                cover = max(cover, i + nums[i]) # 更新覆盖范围
                if cover > len(nums) - 1:
                    return True

        return False

45.跳跃游戏 II

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

生成的测试用例可以到达 nums[n - 1]。

这个题和上面的题不同的是，要求最小。其实还是覆盖范围的问题。

如果我们当前的最大覆盖范围不能到末尾，那就得往下走一步，在看覆盖范围能否到。

但是我们下一步的覆盖范围肯定是要取当前覆盖中下一步的覆盖范围最大的！最远的

所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！

这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。

class Solution:
    def jump(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return 0
        curDistance = 0
        nextDistance = 0
        step = 0
        for i in range(len(nums)):
            nextDistance = max(nextDistance, i + nums[i])
            if i == curDistance:
                step += 1
                curDistance = nextDistance
                if nextDistance >= len(nums) - 1:
                    break
        return step

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

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

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

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

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

这个题很简单，我们肯定想的就是先转换负数，如果还有次数，我们就转换最小的数

其实就包含贪心思想

我们转换负数，是先转换最小的负数【绝对值更大的负数】，

如果负数转换完了，还有次数，且转换完负数的k是奇数，我们减去最小的数！

两次贪心

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort(key=lambda x: abs(s), reverse=True)
        
        for i in range(len(nums)):
            if nums[i] < 0 and k > 0:
                nums[i] = -1 * nums[i]
                k -= 1

        if k % 2 == 1:
            nums[-1] = -1 * nums[-1]

        return sum(nums)