代码随想录day30

作差，将正数求和

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

第二题：

在cover内迭代，不断更新cover范围

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

        cover = 0 + nums[0]
        i = 0
        while i <= cover:
            cover = max(i+nums[i],cover)
            if cover >= len(nums) - 1:
                return True
            i += 1 
        return False

两个范围，一个当前覆盖范围，一个下一步覆盖范围

历覆当前盖值，找到下一步最大覆盖；如果在遍历最后一个数时，覆盖值比数组总数-1 相等或大于：结束。小于：步数加一，最大值赋给覆盖值

class Solution(object):
    def jump(self, nums):
        step = 0

        if len(nums) == 1:
            return 0

        cur = 0  
        nex = 0
        i = 0

        while i <= cur:
            nex = max(i+nums[i],nex)
            if i == cur:
                if cur < len(nums) - 1:
                    step += 1
                    cur = nex
                    if nex >= len(nums) - 1:#上一步没达到，但下一步达到了，也要输出
                        return step
            i += 1

第四题

先按照绝对值排序，从头到尾遍历

如果有剩余（k%2，剩余奇数个只操作1次，偶数个全部抵消），只对最后一个数进行操作

class Solution(object):
    def largestSumAfterKNegations(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        A.sort(key=lambda x: abs(x), reverse=True)  # 第一步：按照绝对值降序排序数组A

        for i in range(len(A)):  # 第二步：执行K次取反操作
            if A[i] < 0 and K > 0:
                A[i] *= -1
                K -= 1

        if K % 2 == 1:  # 第三步：如果K还有剩余次数，将绝对值最小的元素取反
            A[-1] *= -1

        result = sum(A)  # 第四步：计算数组A的元素和
        return result