买卖股票的最佳时机

股票买卖问题可以有一个统一的模板解决，具体来看，每天都有三个状态：第i天，允许交易次数k，是否持有

于是我们为每天的状态标记，有

dp[i][k][1] = max( dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

dp[i][k][0] = max( dp[i-1][k][1] + prices[i], dp[i-1][k][0])

为什么一定要在买入的这天记一次交易（k-1）呢，这是因为，如果是第0天的话，我们无法进行卖出操作，

而只能进行买入操作，将买入操作记为一次交易，这样写的式子更加具有一般形式。

原文题的等价问题是第n天卖掉和第n天不卖掉两种情况取大者，

第i天如果不卖掉，则第i天最大利润dp[i] = dp[i-1]

第i天如果卖掉，则第i天最大利润dp[i] 为当前股票价格prices[i]-之前最小的价格

将两者进行比较取最大值即为最大利润。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp = [0]*len_prices
        dp[0] = 0
        min_price = prices[0]
        for i in range(1, len_prices):
            min_price = min(min_price, prices[i])
            dp[i] = max(prices[i]-min_price, dp[i-1]) # 在第i天卖或不卖股票进行比较
        return dp[-1]

法二：

利用统一模板

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp = [[0]*2 for _ in range(len_prices)]
        dp[0][1] = -prices[0]
        dp[0][0] = 0
        for i in range(1, len_prices):
           dp[i][1] = max(dp[i-1][1], -prices[i])
           dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])

        return dp[-1][0]

 

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp = [[0]*2 for _ in range(len_prices)]
        dp[0][1] = -prices[0]
        dp[0][0] = 0
        for i in range(1, len_prices):
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i])
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
        return dp[-1][0]

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp = [[0]*2 for _ in range(len_prices)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        dp[1][0] = max(prices[1] - prices[0], 0)
        dp[1][1] = max(-prices[0], -prices[1])
        for i in range(2, len_prices):
            dp[i][1] = max(dp[i-1][1], dp[i-2][0]-prices[i])
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i])
        return dp[-1][0]

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp = [[0]*2 for _ in range(len_prices)]
        dp[0][1] = -prices[0]
        dp[0][0] = 0
        for i in range(1, len_prices):
            dp[i][1] = max(dp[i-1][1], dp[i-1][0]-prices[i])
            dp[i][0] = max(dp[i-1][0], dp[i-1][1]+prices[i]-fee)
        return dp[-1][0]

化简使用dp table的大小，由于每次更新的状态都只和相邻状态有关，所以改写如下

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp_i_0 = 0
        dp_i_1 = -float('inf')
        for i in range(0, len_prices):
            dp_i_1 = max(dp_i_1, dp_i_0-prices[i])
            dp_i_0 = max(dp_i_0, dp_i_1+prices[i]-fee)
        return dp_i_0

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        len_prices = len(prices)
        if len_prices <= 1:
            return 0
        dp_i_10 = 0
        dp_i_11 = -float('inf')
        dp_i_20 = 0
        dp_i_21 = -float('inf')
        for i in range(0, len_prices):
            dp_i_11 = max(dp_i_11, -prices[i])
            dp_i_10 = max(dp_i_10, dp_i_11+prices[i])
            dp_i_21 = max(dp_i_21, dp_i_10-prices[i])
            dp_i_20 = max(dp_i_20, dp_i_21+prices[i])
        return dp_i_20