代码随想录算法训练营第四十八天丨121. 买卖股票的最佳时机、122.买卖股票的最佳时机II

121. 买卖股票的最佳时机

方法一：

这题是《算法导论》分治法的一道例题，后续习题中也有使用动态规划解决的习题。

书上主要思路是将股价数组转化成差价数组，记录两天之间的差价，然后求最大连续子区间。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        diff = [prices[i] - prices[i - 1] for i in range(1, len(prices))]
        current_max = global_max = 0
        for d in diff:
            current_max = max(current_max + d, d)
            global_max = max(global_max, current_max)
        return global_max

方法二：

直接使用动态规划的思想。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        #dp[i][0] 不持有股票最大账户收入，dp[i][1]持有股票最大账户收入。
        dp = [[0] * 2 for i in range(len(prices))]
        dp[0][1] = - prices[0]
        for i in range(1, len(prices)):
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
            dp[i][1] = max(dp[i - 1][1], -prices[i])
        return dp[len(prices) - 1][0]

 观察可以发现，实际上dp[i][1]的更新跟dp[i][0]没有一点关系。可以直接把空间复杂度降到O(1)：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        dp0 = 0
        dp1 = - prices[0]
        for i in range(1, len(prices)):
            dp0 = max(dp0, dp1 + prices[i])
            dp1 = max(dp1, -prices[i])
        return dp0

 方法三：

感觉这题动态规划其实不是很合适，因为没有重叠子结构。而贪心可以完成本题，每次记录最小的价格，再求最大差值记录即可，一次贪心选择只剩一个子问题。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        min_price = prices[0]
        max_profit = 0
        for i in range(1, len(prices)):
            min_price = min(prices[i], min_price)
            max_profit = max(max_profit, prices[i] - min_price)
        return max_profit

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

方法一：

对比上一题的动态规划方法，只有更新dp[i][1]的方法不同，因为全程可以买卖多次，持有股票的最大收益来自昨天就持有但是今天不买和昨天没持有今天购买，因为可以交易多次，第二种情况是昨天没持有的最大收益-price[i]。

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        dp = [[0] * 2 for _ in range(len(prices))]
        dp[0][1] = -prices[0]

        for i in range(1, len(prices)):
            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[len(prices) - 1][0]

滚动数组优化：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        dp = [[0] * 2 for _ in range(2)]
        dp[0][1] = -prices[0]

        for i in range(1, len(prices)):
            dp[i % 2][0] = max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] + prices[i])
            dp[i % 2][1] = max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] - prices[i])
        
        return dp[(len(prices) - 1) % 2][0]

方法二：

复习一下贪心写法：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        return sum(prices[i] - prices[i - 1] for i in range(1, len(prices)) if prices[i] - prices[i - 1] > 0)

今日总结：

感觉第一题是中等第二题是简单...

第一题动规解法难以理解的点会在dp[i][1]的更新与dp[i - 1][0]无关，因为全程只能买一次股票，第i天持有说明第i-1天及以前不可能有未持有股票的收益。第二题就好理解多了，可以买多次，以前也能有收益。