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

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

题目链接：122.买卖股票的最佳时机 II
文档讲解： 代码随想录

利润是可以分解的，将其分解为以每天为单位的维度，而不是几天为单位。局部最优，收集每天的正利润，全局最优，就是求得最大利润。

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        res = 0
        for i in range(1, len(prices)):
            temp = prices[i] - prices[i - 1]
            if temp > 0:
                res += temp
        return res

2.55. 跳跃游戏

题目链接：155. 跳跃游戏
文档讲解： 代码随想录

我的思路：for循环遍历每个元素，计算该点到最后一个元素的目标距离，如果目标距离小于等于元素值，那么就说明可以达到。但这样有问题，例如[1,0,1,0]，第二个1可以到达最后，但是无法从第一个1到达第二个1。

标答思路：将问题转化为跳跃覆盖范围是否可以覆盖终点。i 每次移动只能在 cover 的范围内移动，每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。

class Solution(object):
    def canJump(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """ 
        if len(nums) == 1:
            return True
        
        i = 0
        cover = 0
        #python不支持动态修改for循环中的变量，用while代替
        while i <= cover:
            cover = max(i + nums[i], cover)
            if cover >= len(nums) - 1:
                return True
            i += 1
        return False

class Solution(object):
    def canJump(self, nums):
        """
        :type nums: List[int]
        :rtype: 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

3.45.跳跃游戏 II

题目链接：45.跳跃游戏 II
文档讲解： 代码随想录

要从覆盖范围出发，以最小步数增加覆盖范围，覆盖范围一旦覆盖了终点，那么得到的就是最小步数。需要统计两个覆盖范围，当前这步的最大覆盖范围和下一步的最大覆盖范围。到达当前这步的最大覆盖范围的最远距离，还没有达到终点的话，就需要跳一步，范围扩大到下一步的最大覆盖范围，直到跳到终点。

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0
        
        cur = 0
        nex = 0
        res = 0
        for i in range(len(nums)):
            #记录下一步
            nex = max(nex, i + nums[i])
            #判断是否到达当前覆盖范围的最大距离
            if i == cur:
                #判断是否走到终点
                if cur != len(nums) - 1:
                    #没走到
                    res += 1
                    cur = nex
                else:
                    #走到
                    break
        return res

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0

        cur = 0
        nex = 0
        res = 0
        for i in range(len(nums)):
            nex = max(nex, i + nums[i])
            #移动到当前覆盖范围的最大距离
            if i == cur:
                #需要跳一步
                res += 1
                #更新当前最大覆盖范围
                cur = nex
                #判断当前覆盖范围包含终点
                if cur >= len(nums) - 1:
                    #包含则结束
                    break
        return res

针对到达当前覆盖范围的最远距离的特殊情况，可以统一处理，一旦到达此位置，那么步数结果加一。但需要注意的是，for 循环只要遍历到 len(nums) - 2 的位置，当移动到该位置，再跳一步肯定可以到终点；若不移动到该位置，则说明覆盖范围已经包含了终点，不需要再走一步。

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0
        cur = 0
        res = 0
        nex = 0
        for i in range(len(nums) - 1):
            nex = max(nex, i + nums[i])
            if i == cur:
                res += 1
                cur = nex
        return res

可以在上一道跳跃游戏的思路上写。

class Solution(object):
    def jump(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if len(nums) == 1:
            return 0
        
        res = 0
        i = 0
        cover = 0
        while i <= cover:
            #遍历该点可以到达的所有点
            for i in range(cover + 1):
                #更新cover范围
                cover = max(cover, i + nums[i])
                if cover >= len(nums) - 1:
                    return res + 1
            res += 1

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

题目链接：1005.K次取反后最大化的数组和
文档讲解： 代码随想录

这道题的局部最优，是让绝对值大的负数变成正数，当前数值达到最大，从而实现整个数组和达到最大。那么如果将所有负数都转变成正数后，k 仍然大于0，那么就找到最小的正整数进行反转，从而达到整个数组和最大。

解题步骤：
（1）将数组按照元素的绝对值进行排序
（2）从后往前遍历，同时 k 减一
（3）若 k 仍然大于0，那么就反复转变数值最小的元素，将 k 用完
（4）求和

class Solution(object):
    def largestSumAfterKNegations(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        #排序
        nums.sort(key = lambda x:abs(x))
        #取反
        for i in range(len(nums) - 1, -1, -1):
            if nums[i] < 0 and k > 0:
                nums[i] = - nums[i]
                k -= 1
        #如果k仍然大于0
        if k % 2 == 1:
            nums[0] = - nums[0]
        #求和
        res = sum(nums)
        return res