✅DAY28 贪心算法续 | 122.买卖股票的最佳时机II | 55. 跳跃游戏 | 45.跳跃游戏II | 1005.K次取反后最大化的数组和

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

解题思路：取区间内的正数

假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。

相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])

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

55. 跳跃游戏

解题思路：回溯算法（超时），计算当前可以跳跃的最远位置 furthestJump，它等于当前位置加上当前位置的跳跃数 nums[position]，但不能超过数组的末尾。

遍历 nextPosition 从当前位置到 furthestJump 之间的每一个位置，递归调用 backtrack 检查是否可以从这些位置到达末尾。

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        return self.backtracking(nums, 0)
        
    def backtracking(self, nums, position):
        if position == len(nums) -1:
            return True
        furthestJump = min(len(nums)-1, position + nums[position])
        for nextPosition in range(position+1, furthestJump+1):
            if self.backtracking(nums, nextPosition):
                return True
        return False

解题思路：贪心，每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

用cover记录每个位置能覆盖的长度，判断是否可以到达末尾

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        if len(nums) == 1: return True
        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

解题思路：每次i走到当前覆盖范围的末端时，就更新需要的步数，并且把当前覆盖范围更新为前面遍历取得的最大范围。

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

        cur_distance, next_distance, count = 0, 0, 0
        for i in range(len(nums)):
            next_distance = max(next_distance, i + nums[i])
            if i == cur_distance:
                count += 1
                cur_distance = next_distance
                if next_distance >= len(nums)-1:
                    break
        return count

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

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        nums.sort(key= lambda x: abs(x), reverse = True)
        for i in range(len(nums)):
            if nums[i] < 0 and k >0:
                nums[i] *= -1
                k-=1
        if k%2 == 1: # 如果K还有剩余次数，将绝对值最小的元素取反
            nums[-1] *=-1

        return sum(nums)