[LeetCode刷题笔记]123 - 买卖股票的最佳时机 III（C++/Python3/Java/动态规划）

一、题目描述

• 给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
• 设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
• 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例：

输入	输出	解释
prices = [3,3,5,0,0,3,1,4]	6	在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
prices = [1,2,3,4,5]	4	在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
prices = [7,6,4,3,1]	0	在这个情况下, 没有交易完成, 所以最大利润为 0。

提示：

• $1<=prices.length<=10^5$
• $0<=prices[i]<=10^5$

---

二、求解思路：动态规划

1. 通俗易懂版本（三维动态规划，适合初学，但内存消耗和用时均较大）

• 假设 dp[i][j][k] ，其中 i = prices.size()表示第 i 天，j = 2 表示持股和非持股这两个状态，k = 3 表示交易完成的次数（0，1，2共有三种状态）。考虑每天决策完是否买卖后的状态有以下六种情况：
  • dp[i][0][0]，表示截至第 i 天未持股且未发生过一次交易。因此利润一直为 0 ；
  • dp[i][1][0]，表示截至第 i 天持股且未发生过一次交易。分析可得可能是截至上一天未交易过且未持股而今天买了，或者截至上一天未交易过但持股而今天没卖（因为卖出才表示一次交易完成）。
  • dp[i][0][1]，表示截至第 i 天未持股且发生过一次交易。分析可得可能是截至上一天已经交易过一次且未持股而今天没买，或者截至上一天未交易过且持股而今天卖了（卖出交易次数加一）。
  • dp[i][1][1]，表示截至第 i 天持股且发生过一次交易。分析可得可能是截至上一天已经交易过一次且未持股而今天买了，或者截至上一天已经交易过一次且持股而今天没卖。
  • dp[i][0][2]，表示截至第 i 天未持股且发生过两次交易。分析可得可能是截至上一天已经交易过两次且未持股而今天没买，或者截至上一天已经交易过一次且持股而今天卖了。
  • dp[i][1][2]，表示截至第 i 天持股且发生过两次交易。分析可得可能是截至上一天已经交易过两次且未持股而今天买了，或者截至上一天已经交易过两次且持股而今天没卖。
• 由此，可确定各个状态的转移方程为：
  • dp[i][0][0] = 0
  • dp[i][1][0] = max(dp[i-1][0][0]-prices[i], dp[i-1][1][0])
  • dp[i][0][1] = max(dp[i-1][0][1], dp[i-1][1][0]+prices[i])
  • dp[i][1][1] = max(dp[i-1][0][1]-prices[i], dp[i-1][1][1])
  • dp[i][0][2] = max(dp[i-1][0][2], dp[i-1][1][1]+prices[i])
  • dp[i][1][2] = max(dp[i-1][0][2]-prices[i], dp[i-1][1][2])
• 考虑状态的初始值：
  • dp[0][0][0] = 0; dp[0][1][0] = -prices[i]
  • dp[0][0][1] = 0; dp[0][1][1] = -prices[i]
  • dp[0][0][2] = 0; dp[0][1][2] = -prices[i]

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        // 三维状态表示：第i天，j表示是否持有股票，k表示交易完成次数
        int dp[n][2][3];
        dp[0][0][0] = 0; dp[0][1][0] = -prices[0];
        dp[0][0][1] = 0; dp[0][1][1] = -prices[0];
        dp[0][0][2] = 0; dp[0][1][2] = -prices[0];
        for(int i = 1; i < n; i++) {
            dp[i][0][0] = 0; 
            dp[i][1][0] = max(dp[i-1][0][0]-prices[i], dp[i-1][1][0]); 
            dp[i][0][1] = max(dp[i-1][0][1], dp[i-1][1][0]+prices[i]); 
            dp[i][1][1] = max(dp[i-1][0][1]-prices[i], dp[i-1][1][1]); 
            dp[i][0][2] = max(dp[i-1][0][2], dp[i-1][1][1]+prices[i]); 
            dp[i][1][2] = max(dp[i-1][0][2]-prices[i], dp[i-1][1][2]); 
        }
        return dp[n-1][0][2];
    }
};

Python3代码

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        # 三维状态表示：第i天，j表示是否持有股票，k表示交易完成次数
        dp = [[[0,0,0],[0,0,0]] for i in range(0,n)]
        dp[0][0][0] = 0; dp[0][1][0] = -prices[0]
        dp[0][0][1] = 0; dp[0][1][1] = -prices[0]
        dp[0][0][2] = 0; dp[0][1][2] = -prices[0]
        for i in range(1,n):
            dp[i][0][0] = 0; 
            dp[i][1][0] = max(dp[i-1][0][0]-prices[i], dp[i-1][1][0]); 
            dp[i][0][1] = max(dp[i-1][0][1], dp[i-1][1][0]+prices[i]); 
            dp[i][1][1] = max(dp[i-1][0][1]-prices[i], dp[i-1][1][1]); 
            dp[i][0][2] = max(dp[i-1][0][2], dp[i-1][1][1]+prices[i]); 
            dp[i][1][2] = max(dp[i-1][0][2]-prices[i], dp[i-1][1][2]); 

        return dp[n-1][0][2]

Java代码

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        // 三维状态表示：第i天，j表示是否持有股票，k表示交易完成次数
        int[][][] dp = new int[n][2][3];
        dp[0][0][0] = 0; dp[0][1][0] = -prices[0];
        dp[0][0][1] = 0; dp[0][1][1] = -prices[0];
        dp[0][0][2] = 0; dp[0][1][2] = -prices[0];
        for(int i = 1; i < n; i++) {
            dp[i][0][0] = 0; 
            dp[i][1][0] = Math.max(dp[i-1][0][0]-prices[i], dp[i-1][1][0]); 
            dp[i][0][1] = Math.max(dp[i-1][0][1], dp[i-1][1][0]+prices[i]); 
            dp[i][1][1] = Math.max(dp[i-1][0][1]-prices[i], dp[i-1][1][1]); 
            dp[i][0][2] = Math.max(dp[i-1][0][2], dp[i-1][1][1]+prices[i]); 
            dp[i][1][2] = Math.max(dp[i-1][0][2]-prices[i], dp[i-1][1][2]); 
        }
        return dp[n-1][0][2];
    }
}

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(n)$。

---

2. 优化版本（简化状态，需要较深的理解）

• 考虑内存优化：题中要求交易次数最多为两次，因此按照买卖操作数考虑状态，在截至每天结束后有五种情况（但只考虑四种状态）：
  • 未进行任何操作，此时利润一直为 0 （不予考虑）；
  • buyOneTime：只进行过一次买操作；
  • sellOneTime：进行过一次买操作和一次卖操作（成功交易一次）；
  • buyTwoTimes：成功交易过一次基础上，又进行过一次买操作；
  • sellTwoTimes：成功交易过一次基础上，又进行过一次买操作和一次卖操作（成功交易一次）；
• 每一天都可选择不进行任何操作保留上一天的利润，或者进行一次买操作或卖操作而达到上述某种状态，这样可以很容易分析出每种状态的状态转移方程：
  • buyOneTime[i] = max(buyOneTime[i-1], -prices[i])
  • sellOneTime[i] = max(sellOneTime[i-1], buyOneTime[i-1]+prices[i])
  • buyTwoTimes[i] = max(buyTwoTimes[i-1], sellOneTime[i-1]-prices[i])
  • sellTwoTimes[i] = max(sellTwoTimes[i-1], buyTwoTimes[i-1]+prices[i])
• 考虑内存优化：
  • 法一：由于每种状态只与上一时刻状态值有关，因此不用把所有时刻状态都保留，保留上一时刻状态值即可（此处文章中省略，重点理解方法二）；
  • 法二：把上一时刻状态全部改成这一时刻状态即可。
    • buyOneTime = max(buyOneTime, -prices[i])
    • sellOneTime = max(sellOneTime, buyOneTime+prices[i])
    • buyTwoTimes = max(buyTwoTimes, sellOneTime-prices[i])
    • sellTwoTimes = max(sellTwoTimes, buyTwoTimes+prices[i])
    • 理解：以 sellOneTime 为例，以该时刻的 buyOneTime 进行转移，相当于相比用上一时刻的转移，又考虑了在本时刻买入股票的情况，而转移到 sellOneTime 状态考虑的是本时刻卖出一次股票的情况，因此在同一时刻又买入又卖出，不改变利润值，对结果无影响。其他的状态以同样的方式进行理解。
    • 考虑状态的初始值：
      • buyOneTime = -prices[i]
      • sellOneTime = 0
      • buyTwoTimes = -prices[i]
      • sellTwoTimes = 0

C++代码

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int buyOneTime = -prices[0], sellOneTime = 0;
        int buyTwoTimes = -prices[0], sellTwoTimes = 0;
        for(int i = 1; i < n; i++) {
            buyOneTime   = max(buyOneTime  , -prices[i]);
            sellOneTime  = max(sellOneTime , buyOneTime + prices[i]);
            buyTwoTimes  = max(buyTwoTimes , sellOneTime - prices[i]);
            sellTwoTimes = max(sellTwoTimes, buyTwoTimes + prices[i]);
        }
        return sellTwoTimes;
    }
};

Python3代码

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        buyOneTime, sellOneTime = -prices[0], 0
        buyTwoTimes, sellTwoTimes = -prices[0], 0
        for i in range(1,n):
            buyOneTime   = max(buyOneTime  , -prices[i])
            sellOneTime  = max(sellOneTime , buyOneTime + prices[i])
            buyTwoTimes  = max(buyTwoTimes , sellOneTime - prices[i])
            sellTwoTimes = max(sellTwoTimes, buyTwoTimes + prices[i])

        return sellTwoTimes

Java代码

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        int buyOneTime = -prices[0], sellOneTime = 0;
        int buyTwoTimes = -prices[0], sellTwoTimes = 0;
        for(int i = 1; i < n; i++) {
            buyOneTime   = Math.max(buyOneTime  , -prices[i]);
            sellOneTime  = Math.max(sellOneTime , buyOneTime + prices[i]);
            buyTwoTimes  = Math.max(buyTwoTimes , sellOneTime - prices[i]);
            sellTwoTimes = Math.max(sellTwoTimes, buyTwoTimes + prices[i]);
        }
        return sellTwoTimes;
    }
}

复杂度分析

• 时间复杂度：$O(n)$。
• 空间复杂度：$O(1)$。

---

三、参考文章

[1] https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/solution/tong-su-yi-dong-de-dong-tai-gui-hua-jie-fa-by-marc/
[2] https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/solution/mai-mai-gu-piao-de-zui-jia-shi-ji-iii-by-wrnt/