代码随想录算法训练营第二十七天｜122.买卖股票的最佳时机II 、55. 跳跃游戏、 45.跳跃游戏II 、 1005.K次取反后最大化的数组和

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

本题首先要清楚两点：

• 只有一只股票！
• 当前只有买股票或者卖股票的操作

想获得利润至少要两天为一个交易单元

思路：计算利润序列，只需要收集正利润

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        #计算利润序列，只需要收集正利润
        profit = []
        for i in range(len(prices)-1):
            profit.append(prices[i+1] - prices[i])

        result = 0
        for p in profit:
            if p > 0:
                result += p
        return result

55. 跳跃游戏

i 每次移动只能在 cover 的范围内移动，每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。

而 cover 每次只取 max(该元素数值补充后的范围, cover 本身范围)。

如果 cover 大于等于了终点下标，直接 return true 就可以了。

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

45. 跳跃游戏 II

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

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

class Solution:
    def jump(self, nums: List[int]) -> int:
        if len(nums) == 1:
            return 0

        cur_distance = 0  # 当前覆盖最远距离下标
        ans = 0  # 记录走的最大步数
        next_distance = 0  # 走下一步覆盖最远距离下标
        
        for i in range(len(nums)):
            next_distance = max(next_distance, i+nums[i]) 
            if i == cur_distance:
                ans += 1 #走一步(即可以是到当前最远距离的位置，也可以是向前移动一步)
                cur_distance = next_distance #更新当前覆盖的最远距离下标
                if next_distance >= len(nums) - 1:
                    break

        return ans
            

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

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort()
        
        # 统计有多少个负数
        neg_cnt = 0
        for n in nums:
            if n < 0:
                neg_cnt += 1
        
        # 如果没有负数或 k 小于等于负数的数量，直接将前 k 个负数取反
        if neg_cnt == 0:
            # 如果没有负数，检查 k 的奇偶性
            if k % 2 != 0:
                nums[0] = -nums[0]
        elif k <= neg_cnt:
            for i in range(k):
                nums[i] = -nums[i]
        else:
            # 先将所有负数取反
            for i in range(neg_cnt):
                nums[i] = -nums[i]
            # 剩下的次数处理最小的绝对值元素
            k -= neg_cnt
            # 如果剩下的次数是奇数，最小的绝对值元素再取反一次
            if k % 2 != 0:
                nums.sort()
                nums[0] = -nums[0]
        
        return sum(nums)