LeetCode 123. 买卖股票的最佳时机 III（困难）

企业开发 2025-04-12 21:26
0 阅读

题目描述

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

示例 2：

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

示例 3：

输入：prices = [7,6,4,3,1] 
输出：0 
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

提示：

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

问题分析

这道题是"买卖股票的最佳时机"系列的第三题，相比前两题，这里的限制是：

  1. 最多完成两笔交易
  2. 必须先卖出之前的股票，才能再次购买

要解决这个问题，我们需要思考如何用动态规划来表示不同的交易状态。

由于我们最多可以完成两笔交易，每笔交易有买入和卖出两个操作，所以我们可以将问题分为5个状态：

  1. 未进行任何操作
  2. 第一次买入股票
  3. 第一次卖出股票
  4. 第二次买入股票
  5. 第二次卖出股票

解题思路

动态规划解法

定义状态

在动态规划解法中，我们定义一个二维数组 dp[i][j]，其中：

  • i 表示第i天
  • j 表示当前的状态（0到4）
  • j=0: 未进行任何操作
  • j=1: 进行了第一次买入
  • j=2: 进行了第一次卖出
  • j=3: 进行了第二次买入
  • j=4: 进行了第二次卖出

状态转移

无操作状态
  • 前一天就没有任操作状态，今天什么都不做：dp[i-1][0]

第一次买入状态

  • 前一天就是第一次买入状态，今天什么都不做：dp[i-1][1]
  • 前一天就没有任操作状态，今天进行第一次买入：dp[i-1][0] - prices[i]
  • 取两者的最大值：dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])

第一次卖出状态

  • 前一天就是第一次卖出状态，今天什么都不做：dp[i-1][2]
  • 前一天是第一次买入状态，今天卖出，完成第一次卖出：dp[i-1][1] + prices[i]
  • 取两者的最大值：dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])

第二次买入状态

  • 前一天就是第二次买入状态，今天什么都不做：dp[i-1][3]
  • 前一天是第一次卖出状态，今天进行第二次买入：dp[i-1][2] - prices[i]
  • 取两者的最大值：dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])

第二次卖出状态

  • 前一天就是第二次卖出状态，今天什么都不做：dp[i-1][4]
  • 前一天是第二次买入状态，今天卖出，完成第二次卖出：dp[i-1][3] + prices[i]
  • 取两者的最大值：dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])

状态转移方程如下：

  • dp[i][0] = dp[i-1][0]：保持未操作状态
  • dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])：保持第一次买入状态，或者今天进行第一次买入
  • dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i])：保持第一次卖出状态，或者今天进行第一次卖出
  • dp[i][3] = max(dp[i-1][3], dp[i-1][2] - prices[i])：保持第二次买入状态，或者今天进行第二次买入
  • dp[i][4] = max(dp[i-1][4], dp[i-1][3] + prices[i])：保持第二次卖出状态，或者今天进行第二次卖出

最终的最大利润即为 dp[n-1][4]，表示最后一天完成两次交易后的最大利润。

初始化

  • 无任何操作：dp[0][0] = 0
  • 第一次买入：dp[0][1] = -prices[0]
  • 第一次卖出：dp[0][2] = 0
  • 第二次买入： dp[0][3] = -prices[0]
  • 第二次卖出：dp[0][4] = 0

虽然在第一天同时进行第一次买入和第二次买入是没有实际意义的（因为必须先卖出才能进行第二次买入），但这样初始化可以简化代码。事实上，第二次买入的状态会在后续的遍历中被正确更新。

详细执行过程图解

以示例 [3,3,5,0,0,3,1,4] 为例，让我们详细跟踪算法的执行过程：

初始状态（第1天）：

  • 价格 = 3
  • buy1 = -3（第一次买入）
  • sell1 = 0（未卖出）
  • buy2 = -3（第一次买入后立即第二次买入，无意义初始化）
  • sell2 = 0（未卖出）

第2天：

  • 价格 = 3
  • buy1 = max(-3, -3) = -3（保持不变）
  • sell1 = max(0, -3+3) = 0（保持不变）
  • buy2 = max(-3, 0-3) = -3（保持不变）
  • sell2 = max(0, -3+3) = 0（保持不变）

第3天：

  • 价格 = 5
  • buy1 = max(-3, -5) = -3（保持不变）
  • sell1 = max(0, -3+5) = 2（当天卖出）
  • buy2 = max(-3, 0-5) = -3（保持不变）
  • sell2 = max(0, -3+5) = 2（当天卖出）

第4天：

  • 价格 = 0
  • buy1 = max(-3, 0) = 0（当天买入）
  • sell1 = max(2, -3+0) = 2（保持不变）
  • buy2 = max(-3, 2-0) = 2（当天买入）
  • sell2 = max(2, -3+0) = 2（保持不变）

第5天：

  • 价格 = 0
  • buy1 = max(0, 0) = 0（保持不变）
  • sell1 = max(2, 0+0) = 2（保持不变）
  • buy2 = max(2, 2-0) = 2（保持不变）
  • sell2 = max(2, 2+0) = 2（保持不变）

第6天：

  • 价格 = 3
  • buy1 = max(0, -3) = 0（保持不变）
  • sell1 = max(2, 0+3) = 3（当天卖出）
  • buy2 = max(2, 2-3) = 2（保持不变）
  • sell2 = max(2, 2+3) = 5（当天卖出）

第7天：

  • 价格 = 1
  • buy1 = max(0, -1) = 0（保持不变）
  • sell1 = max(3, 0+1) = 3（保持不变）
  • buy2 = max(2, 3-1) = 2（保持不变）
  • sell2 = max(5, 2+1) = 5（保持不变）

第8天：

  • 价格 = 4
  • buy1 = max(0, -4) = 0（保持不变）
  • sell1 = max(3, 0+4) = 4（当天卖出）
  • buy2 = max(2, 3-4) = 2（保持不变）
  • sell2 = max(5, 2+4) = 6（当天卖出）

最终结果 = sell2 = 6

这个结果对应的交易是：

  1. 在第4天（价格=0）买入，在第6天（价格=3）卖出，利润=3
  2. 在第7天（价格=1）买入，在第8天（价格=4）卖出，利润=3

总利润 = 3 + 3 = 6

股票交易时间线图解

   价格
    ^
5   |      *
    |
4   |              *
    |
3   |* *        *   
    |
2   |               
    |
1   |            *  
    |
0   |      * *      
    +---------------> 时间
     1 2 3 4 5 6 7 8
 
交易策略:
第4天: 买入 (价格=0)
第6天: 卖出 (价格=3, 利润=3)
第7天: 买入 (价格=1)
第8天: 卖出 (价格=4, 利润=3)
总利润: 3+3=6

交易策略:

第4天: 买入 (价格=0)

第6天: 卖出 (价格=3, 利润=3)

第7天: 买入 (价格=1)

第8天: 卖出 (价格=4, 利润=3)

总利润: 3+3=6

Java 动态规划实现

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        
        int n = prices.length;
        // dp[i][j] 表示第i天状态j下的最大利润
        // j=0: 未进行任何操作
        // j=1: 进行了第一次买入
        // j=2: 进行了第一次卖出
        // j=3: 进行了第二次买入
        // j=4: 进行了第二次卖出
        int[][] dp = new int[n][5];
        
       // 初始状态（第一天）
        dp[0][0] = 0;           // 未进行任何操作
        dp[0][1] = -prices[0];  // 第一次买入
        dp[0][2] = 0;           // 第一次卖出（不可能发生，因为还没买入）
        dp[0][3] = -prices[0];  // 第二次买入（不可能发生，初始化只是为了统一处理）
        dp[0][4] = 0;           // 第二次卖出（不可能发生）
        
        // 状态转移
        for (int i = 1; i < n; i++) {
            // 未操作状态保持不变
            dp[i][0] = dp[i-1][0];
            // 第一次买入：要么保持前一天的状态，要么今天买入
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]);
            // 第一次卖出：要么保持前一天的状态，要么今天卖出
            dp[i][2] = Math.max(dp[i-1][2], dp[i-1][1] + prices[i]);
            // 第二次买入：要么保持前一天的状态，要么今天买入
            dp[i][3] = Math.max(dp[i-1][3], dp[i-1][2] - prices[i]);
            // 第二次卖出：要么保持前一天的状态，要么今天卖出
            dp[i][4] = Math.max(dp[i-1][4], dp[i-1][3] + prices[i]);
        }
        
        return dp[n-1][4];
    }
}

C# 动态规划实现

public class Solution {
    public int MaxProfit(int[] prices) {
        if (prices == null || prices.Length <= 1) {
            return 0;
        }
        
        int n = prices.Length;
        // dp[i][j] 表示第i天状态j下的最大利润
        // j=0: 未进行任何操作
        // j=1: 进行了第一次买入
        // j=2: 进行了第一次卖出
        // j=3: 进行了第二次买入
        // j=4: 进行了第二次卖出
        int[][] dp = new int[n][];
        for (int i = 0; i < n; i++) {
            dp[i] = new int[5];
        }
        
        // 初始状态
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;
        
        // 状态转移
        for (int i = 1; i < n; i++) {
            dp[i][0] = dp[i-1][0];
            dp[i][1] = Math.Max(dp[i-1][1], dp[i-1][0] - prices[i]);
            dp[i][2] = Math.Max(dp[i-1][2], dp[i-1][1] + prices[i]);
            dp[i][3] = Math.Max(dp[i-1][3], dp[i-1][2] - prices[i]);
            dp[i][4] = Math.Max(dp[i-1][4], dp[i-1][3] + prices[i]);
        }
        
        return dp[n-1][4];
    }
}

空间优化解法

观察上面的状态转移方程，我们可以发现每个状态只依赖于前一天的状态。因此，我们可以使用几个变量来代替整个二维数组，将空间复杂度从O(n)降低到O(1)。

我们定义以下变量：

  • buy1: 表示第一次买入后的最大利润
  • sell1: 表示第一次卖出后的最大利润
  • buy2: 表示第二次买入后的最大利润
  • sell2: 表示第二次卖出后的最大利润

状态转移方程简化为：

  • buy1 = max(buy1, -prices[i])
  • sell1 = max(sell1, buy1 + prices[i])
  • buy2 = max(buy2, sell1 - prices[i])
  • sell2 = max(sell2, buy2 + prices[i])

 Java 空间优化实现

class Solution {
    public int maxProfit(int[] prices) {
        // 边界条件检查
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        
        // 初始化四个状态变量
        int buy1 = -prices[0];  // 第一次买入后的最大利润
        int sell1 = 0;          // 第一次卖出后的最大利润
        int buy2 = -prices[0];  // 第二次买入后的最大利润
        int sell2 = 0;          // 第二次卖出后的最大利润
        
        // 遍历价格数组
        for (int i = 1; i < prices.length; i++) {
            // 更新四个状态
            buy1 = Math.max(buy1, -prices[i]);               // 第一次买入
            sell1 = Math.max(sell1, buy1 + prices[i]);       // 第一次卖出
            buy2 = Math.max(buy2, sell1 - prices[i]);        // 第二次买入
            sell2 = Math.max(sell2, buy2 + prices[i]);       // 第二次卖出
        }
        
        // 最大利润是完成两次交易后的结果
        return sell2;
    }
}

C# 空间优化实现

public class Solution {
    public int MaxProfit(int[] prices) {
        // 边界条件检查
        if (prices == null || prices.Length <= 1) {
            return 0;
        }
        
        // 初始化四个状态变量
        int buy1 = -prices[0];  // 第一次买入后的最大利润
        int sell1 = 0;          // 第一次卖出后的最大利润
        int buy2 = -prices[0];  // 第二次买入后的最大利润
        int sell2 = 0;          // 第二次卖出后的最大利润
        
        // 遍历价格数组
        for (int i = 1; i < prices.Length; i++) {
            // 更新四个状态
            buy1 = Math.Max(buy1, -prices[i]);              // 第一次买入
            sell1 = Math.Max(sell1, buy1 + prices[i]);      // 第一次卖出
            buy2 = Math.Max(buy2, sell1 - prices[i]);       // 第二次买入
            sell2 = Math.Max(sell2, buy2 + prices[i]);      // 第二次卖出
        }
        
        // 最大利润是完成两次交易后的结果
        return sell2;
    }
}

复杂度分析

  • 时间复杂度：O(n)，其中 n 是价格数组的长度。我们只需要遍历一次数组。
  • 空间复杂度：
  • 标准DP版本：O(n)，使用了一个n×5的二维数组
  • 空间优化版本：O(1)，只使用了4个变量

猜你喜欢

目录

热门文章