【LeetCode每日一题】——123.买卖股票的最佳时机 III

一【题目类别】

• 动态规划

二【题目难度】

• 困难

三【题目编号】

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

四【题目描述】

• 给定一个数组，它的第 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

六【解题思路】

• 整体利用动态规划的思路，但是本题较难，因为状态较多，一共可以分五种状态，对于任意一天：
  • 没有任何操作
  • 第一次买入
  • 第一次卖出
  • 第二次买入
  • 第二次卖出
• 那么对于任意一天五种情况的动态转移方程是什么呢？需要注意，每种情况我们都要取最大值，表示此天的操作获得的最大利润：
  • 没有任何操作：
    • 直接沿用前一天没有任何操作的状态，其实本步也可以不在代码中展示，因为没有任何变化，但是为了思路连贯，还是放到代码中了
  • 第一次买入：
    • 第$i$天买入股票，那么$dp[i][1]=dp[i-1][0]-prices[i]$，表示之前没有操作，用之前的利润减去当天买入股票的价钱
    • 第$i$天没有操作，那么沿用前一天的状态，即：$dp[i][1]=dp[i-1][1]$
    • 所以对于此种情况的动态转移方程为：$dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i])$
  • 第一次卖出：
    • 第$i$天卖出股票，那么$dp[i][2]=dp[i-1][1]+prices[i]$，表示之前买入过股票，用之前的利润加上当天卖出股票的价钱
    • 第$i$天没有操作，那么沿用前一天的状态，即：$dp[i][2]=dp[i-1][2]$
    • 所以对于此种情况的动态转移方程为：$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])$
• 需要注意最后一次卖出股票后，可以获得最大利润，因为每次都是按照最大利润计算的
• 另外还需要注意，初始化参数时，第一次的股票也有五种情况，对于没有操作和卖出这几种状态因为获取不到利润，所以利润为0，而对于买入的状态，因为初始化没有钱，所以可以获得的最大利润就是第一支股票的负数，也就是属于欠钱的状态，再通过后面的状态转移方程获取最大利润
• 最后返回结果即可

七【题目提示】

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

八【时间频度】

• 时间复杂度：$O(n)$，其中$n$为数组大小
• 空间复杂度：$O(n)$，其中$n$为数组大小

九【代码实现】

1. Java语言版

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        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<prices.length;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];
    }
}

2. C语言版

int maxProfit(int* prices, int pricesSize)
{
    int** dp = (int**)malloc(sizeof(int*)*pricesSize);
    for(int i = 0;i<pricesSize;i++)
    {
        dp[i] = (int*)calloc(5,sizeof(int));
    }
    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<pricesSize;i++)
    {
        dp[i][0] = dp[i-1][0];
        dp[i][1] = fmax(dp[i-1][1],dp[i-1][0] - prices[i]);
        dp[i][2] = fmax(dp[i-1][2],dp[i-1][1] + prices[i]);
        dp[i][3] = fmax(dp[i-1][3],dp[i-1][2] - prices[i]);
        dp[i][4] = fmax(dp[i-1][4],dp[i-1][3] + prices[i]);
    }
    return dp[pricesSize - 1][4];
}

3. Python版

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp = [[0] * 5 for _ in range(n)]
        dp[0][0] = 0
        dp[0][1] = -prices[0]
        dp[0][2] = 0
        dp[0][3] = -prices[0]
        dp[0][4] = 0
        for i in range(1,n):
            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])
        return dp[n - 1][4]

十【提交结果】

1. Java语言版
   

2. C语言版
   

3. Python语言版