力扣的股票问题python

输入关键字股票，出来的题目如下：

剑指 Offer 63. 股票的最大利润

一次买卖，不求代码NB，只求解题，用动态规划：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[0,0]for i in range(n)]
        # 0 表示没有持有，1 表示持有
        dp[0][1] = -prices[0]
        for i in range(1,n):
            # 没有持有，从上一个没有持有，或者，上一个持有的卖掉
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i])
            # 持有，从上一个持有，或者，从没有持有的状态买入，注意这里是直接为-prices[i]，因为只能操作一次
            dp[i][1] = max(dp[i-1][1],-prices[i])
        return dp[n-1][0]

只求能过。
在这个基础上去考虑无限次操作的也是一样的。比如题目：
122. 买卖股票的最佳时机 II

代码：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[0,0] for i in range(n)]
        dp[0][1] = -prices[0]
        for i in range(1,n):
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i])
            # 多次操作的转移状态就不一样了
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i])
        return dp[n-1][0]

好理解，但是效率不高。只求解题

再看一种，如果是无限次操作机会加上有冷冻期的情况。
309. 最佳买卖股票时机含冷冻期

冷冻期的存在表示你只能卖掉前天的，即i-2的

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[0,0] for i in range(n)]
        # 0 没有持有 1 持有 
        dp[0][1] = -prices[0]
        dp[1][0] = max(dp[0][0],dp[0][1] + prices[1])
        dp[1][1] = max(dp[0][1],-prices[1])
        for i in range(2,n):
            dp[i][0] = max(dp[i-1][0],dp[i-1][1] + prices[i])
            # 这里的i-2表示只能是冻结期之前的
            dp[i][1] = max(dp[i-1][1],dp[i-2][0]-prices[i])
        return dp[n-1][0]

123. 买卖股票的最佳时机 III

操作次数只能是2次，所以需要控制一下次数，在动态规划里面多加一个状态

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[[0,0]for _ in range(3)]for i in range(n)]
        dp[0][1][1] = -prices[0]
        dp[0][2][1] = -prices[0]
        for i in range(1,n):
            # k需要倒着来因为第2次买入的一定是在第一次卖掉之后，
            for k in range(2,0,-1):
                # 没有持有的状态
                # 保持上次的记录，不操作
                # 卖掉手上持有的
                dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1]+prices[i])
                # 持有
                # 买入
                # 保持不变
                dp[i][k][1] = max(dp[i-1][k][1],dp[i-1][k-1][0]-prices[i])
        return dp[n-1][2][0]

如果这个操作次数是自己控制的，那么和次数能操作两次没什么区别，只是需要改变一下初始化的时候的状态
188. 买卖股票的最佳时机 IV

class Solution:
    def maxProfit(self, k: int, prices: List[int]) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[[0,0]for i in range(k+1)]for j in range(n)]
        # 初始化的时候，不管操作多少次，在第一天的时候持有都是-prices[0]
        for i in range(1,k+1):
            dp[0][i][1] = -prices[0]
        for i in range(1,n):
            for j in range(k,0,-1):
                dp[i][j][0] = max(dp[i-1][j][0],dp[i-1][j][1]+prices[i])
                dp[i][j][1] = max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i])
        return dp[n-1][k][0]

如果股票在卖出的时候含有手续费：
714. 买卖股票的最佳时机含手续费

卖出的时候含手续费，操作次数无限，我们在卖出状态的利润里面减去手续费即可

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        if n == 0 or n == 1:
            return 0
        dp = [[0,0] for i in range(n)]
        dp[0][1] = -prices[0]
        for i in range(1,n):
            # 减去手续费
            dp[i][0] = max(dp[i-1][0],dp[i-1][1]+prices[i]-fee)
            dp[i][1] = max(dp[i-1][1],dp[i-1][0]-prices[i])
        return dp[n-1][0]