Day 30 | 122.买卖股票的最佳时机II、55. 跳跃游戏 、45.跳跃游戏II、 1005.K次取反后最大化的数组和

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

本题解法很巧妙，本题大家可以先自己思考一下然后再看题解，会有惊喜！

https://programmercarl.com/0122.买卖股票的最佳时机II.html
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]

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

示例 2:

输入: [1,2,3,4,5]

输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3:

输入: [7,6,4,3,1]

输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思考

贪心和动态规划两种方法。与121题的区别是每天都可以买卖。

1. 贪心

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profit = 0
        for i in range(1,len(prices)):
            if prices[i]-prices[i-1]>0:
                # 假设可以n+0交易，当天买当天卖，只收集每天正利润
                profit+=prices[i]-prices[i-1] 
        return profit

2. 动态规划

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # dp[i][0] 第i天持有股票时的最多现金
        # dp[i][1] 第i天不持有股票的最多现金
        dp = [[0] * 2 for _ in range(len(prices))]
        dp[0][0] = -prices[0]
        dp[0][1] = 0
        for i in range(1,len(prices)):
            #可以每天交易
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]-prices[i])
            dp[i][1] = max(dp[i-1][1],prices[i]+dp[i-1][0])
        return dp[len(prices)-1][1]

55. 跳跃游戏

本题如果没接触过，很难想到，所以不要自己憋时间太久，读题思考一会，没思路立刻看题解

https://programmercarl.com/0055.跳跃游戏.html
给定一个非负整数数组，你最初位于数组的第一个位置。

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

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

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:

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

思考

跳几步其实不是很重要，主要是看cover的范围，在cover范围内，逐步遍历各个元素，动态cover范围，直到i大于cover无法跳跃或者cover超过最后的位置。

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        cover = 0
        for i in range(len(nums)):
            if cover >= len(nums)-1:
                return True
            if i<=cover:
                cover = max(cover,i+nums[i])
            else:
                return False

45.跳跃游戏II

本题同样不容易想出来。贪心就是这样，有的时候 会感觉简单到离谱，有时候，难的不行，主要是不容易想到。

https://programmercarl.com/0045.跳跃游戏II.html
给定一个非负整数数组，你最初位于数组的第一个位置。

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

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

示例:

输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明: 假设你总是可以到达数组的最后一个位置。

思考

这道题相比上一题还是有点难度的，比较难想到。

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

1005.K次取反后最大化的数组和
本题简单一些，估计大家不用想着贪心 ，用自己直觉也会有思路。
https://programmercarl.com/1005.K次取反后最大化的数组和.html
给定一个整数数组 A，我们只能用以下方法修改该数组：我们选择某个索引 i 并将 A[i] 替换为 -A[i]，然后总共重复这个过程 K 次。（我们可以多次选择同一个索引 i。）

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

示例 1：

输入：A = [4,2,3], K = 1
输出：5
解释：选择索引 (1) ，然后 A 变为 [4,-2,3]。
示例 2：

输入：A = [3,-1,0,2], K = 3
输出：6
解释：选择索引 (1, 2, 2) ，然后 A 变为 [3,1,0,2]。
示例 3：

输入：A = [2,-3,-1,5,-4], K = 2
输出：13
解释：选择索引 (1, 4) ，然后 A 变为 [2,3,-1,5,4]。

思考

不是太难的一道题，考察代码实现方式。

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort(key=lambda x:abs(x),reverse =True)
        i = 0
        sum_ = 0
        for c in nums:
            if i == k:
                sum_+=c
                continue
            if c < 0:
                sum_+=-c
                i+=1
            else:
                sum_+=c
        if i>=k:
            return sum_
        else:
            if (k-i)%2 == 0:
                return sum_
            else:
                return sum_ - 2 * abs(nums[-1])