【代码随想录|第八章贪心算法p2 122. 买卖股票的最佳时机，55. 跳跃游戏，45. 跳跃游戏 II，1005. k次取反后最大化的数组和】

---

python

一、122. 买卖股票的最佳时机

内容
122. 买卖股票的最佳时机
晕：转换思路
我的思路：寻找极大极小值
而标答的思路：计算每天的利润，然后计算其中的最大利润和（其实就是只要加正利润就行，一下子简单了很多）

1.核心代码

代码如下（示例）：

class Solution:
    def maxProfit(self,price):
        profit=[]
        sum=0
        for i in range(1,len(price)):
            profit.append(price[i]-price[i-1])
            if profit[i-1] >0:
                sum=sum+profit[i-1]
        return  sum

有了思路之后超级简单

2.输入输出

if __name__=="__main__":
    prices=list(map(int,input().strip("[]").split(",")))
    solution=Solution()
    result=solution.maxProfit(prices)
    print(result)

二、55. 跳跃游戏

内容
55. 跳跃游戏
转换思路：算每一种情况×——只需算最大覆盖情况√

我又悟了！！

因为不管前面的索引所代表可跳的步长有多大，最后都是要通过跳到另一个索引，再跳到最后的！！！
所以他这个根本就不是几个索引的值叠加的问题！！
他本质就是针对每一个索引+该索引所代表的值能否覆盖最终点的问题！！！

但是，也要注意不同索引之间是否能连接的问题，代码if i<=cover

1.核心代码

代码如下（示例）：

class Solution:
    def canJump(self,nums):
        cover=0
        for i in range(len(nums)):
            if i<=cover: #表示这个索引可以和前面的索引连接
                cover=max(i+nums[i],cover)
                if cover >= len(nums)-1:
                    return  True
        return  False

2.输入输出

if __name__=="__main__":
    nums=list(map(int,input().strip("[]").split(",")))
    solution=Solution()
    result=solution.canJump(nums)
    print(result)

三、45. 跳跃游戏 II

45. 跳跃游戏 II
额啊，有点难，没心思细想了
改用动态规划
只看没自己写

注意dp的含义是最少步数，下标是索引
关系式是，如果获得当前的最少步长是min【原来的最小步长，和新的最小步长（可达的上一步加一步）+1】

1.核心代码

代码如下（示例）：

class Solution:
    def jump(self,nums):
        result=[10**4+1]*len(nums)
        result[0]=0

        for i in range(len(nums)):
            for j in range(nums[i]+1):
                if i+j<len(nums):
                    result[i+j]=min(result[i+j],result[i]+1)
        return result[-1]

2.输入输出

if __name__=="__main__":
    nums=list(map(int,input().strip("[]").split(",")))
    solution=Solution()
    result=solution.jump(nums)
    print(result)

四、1005. k次取反后最大化的数组和

1005. k次取反后最大化的数组和
额啊，这题也有点难，思路我是能想到，但是实际写的时候有很多问题

思路：
1、当有负的时候，先把负从大到小
2、当没负的，一直重复弄最小的

实际中：

因为要从大到小，所以要降序，注意：因为最后是取可能负转正之后的最小值，所以先取绝对值的降序，然后在取反操作中筛选小于0的

在都为正的情况下，因为两次取反等于无，所以只要看是否为奇数，做一次操作就行了

这题也没有自己做，只是看了一下思路

1.核心代码

代码如下（示例）：

class Solution:
    def largestSumAfterKNegations(self,nums,k):
        nums.sort(key=lambda x:abs(x),reverse=True)
        for i in range(len(nums)):
            if nums[i]<0 and k>0:
                nums[i]=-nums[i]
                k=k-1
        if k%2 ==1:
            nums[-1]=-nums[-1]
        result=sum(nums)
        return result

2.输入输出

if __name__=="__main__":
    nums=list(map(int,input().strip("[]").split(",")))
    k=input()
    solution=Solution()
    result=solution.largestSumAfterKNegations(nums,k)
    print(result)

总结

输入输出