更弱智的算法学习 day28

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

由于在任何时候最多智能拥有一只股票，但是可以多次买卖。也即只要确保每一次都赚钱，就会得到整体最优。

因此维护一个当前最低价格，初始化为inf，在遍历向前时一旦发现最低价格，更新最低价格；如果遇到更高价格，那么立刻获取收益，也即此时的价格减去最低价格。然后把最低价格设定为此时的价格，继续寻找最低价格

python 复制代码

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        minprice = inf
        res = 0

        for i in prices:
            minprice = min(minprice, i)
            if i > minprice:
                res += i-minprice
                minprice = i

        return res

55. 跳跃游戏

考虑一个能跳跃到的最大距离，对于数组中位置i来说，其可跳跃到的最大距离是i+nums【i】。不断遍历数组，如果在i位置时，最大距离小于i，也即i无法达到，则返回False。否则，不断更新最大距离，直到找到能越过或到达最后一个下标的位置。返回True

python 复制代码

class Solution:
    def canJump(self, nums: List[int]) -> bool:

        maxlength = 0

        for i in range(len(nums)):
            if i > maxlength:
                return False

            maxlength = max(maxlength, i+nums[i])

            if maxlength >= len(nums)-1:
                return True

45.跳跃游戏II

考虑如何每次跨步到最远的的地方，以减少跨步数量。

**maxstep** ：从当前跳跃范围内已遍历的位置 能够到达的最远位置，而不仅仅是当前位置 i的 i + nums[i]。它是在当前跳跃范围内，不断更新得到的最大值。
**jumpedge** ：当前跳跃能到达的边界。当遍历到该边界时，说明当前跳跃的潜力已用尽，必须进行下一次跳跃，并将边界更新为 farthest。

定义maxstep为最大跨步范围，也即以当前位置i为例，当前能达到的maxstep就是位置i加上i位置的nums[i]。定义跨步边界jumpedge，也即截至目前，不进行下一跳时能到达的最大距离，不断遍历数组，更新maxstep，如果位置i已经达到了跨步边界，那么不得不向前跨越，计数+1，并把i位置的新的最大跨步范围设定为边界。如果越过了，返回即可。

python 复制代码

class Solution:
    def jump(self, nums: List[int]) -> int:
        #每次都走最长（本次加下次）的距离
        maxstep = 0
        jumpedge = 0
        count = 0

        for i in range(len(nums)-1):
            maxstep = max(maxstep, i+nums[i])

            if jumpedge == i:
                count += 1
                jumpedge = maxstep

            if jumpedge >= len(nums)-1:
                break
            
        return count

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

答辩代码来咯。

思想其实还好，写的有点复杂。目标就是优先处理最小的负数，处理完小负数如果还有多余的反转次数，且反转次数为单数，那么处理绝对值最小的数防止产生影响。

python 复制代码

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        sums = 0
        nums.sort()
        print(nums)
        n = len(nums)
        count = 0
        for i in range(n):
            if nums[i] < 0:
                count += 1
        if count<=k:
            for j in range(count):
                nums[j] = -nums[j]
                print(nums)
            if (k-count)%2==0:
                for q in nums:
                    sums += q
                return sums
            else:
                if count < n:
                    minnum = min(nums[count-1], nums[count])
                    print(minnum)
                else:
                    minnum = nums[count-1]
                    print(minnum)
                for p in nums:
                    sums += p
                return sums-2*minnum
                    
        else:
            for m in range(0,k):
                nums[m] = -nums[m]
            for c in nums:
                sums += c
            return sums

来个正常的代码，按照绝对值的大小进行排序，由大到小，然后依次处理非负数。如果有剩余且非负，那么处理最后一个数

python 复制代码

class Solution:
    def largestSumAfterKNegations(self, nums: List[int], k: int) -> int:
        # 按绝对值从大到小排序
        nums.sort(key=lambda x: -abs(x))
        
        # 优先取反负数
        for i in range(len(nums)):
            if k > 0 and nums[i] < 0:
                nums[i] = -nums[i]
                k -= 1
        
        # 如果k还有剩余且为奇数
        if k % 2 == 1:
            nums[-1] = -nums[-1]
        
        return sum(nums)