通过最多买卖两次股票获得最大利润

问题描述

给定一个数组prices，它的第i个元素prices[i]表示一支给定股票在第i天的价格。你最多可以完成两笔交易（一笔买，一笔卖算作一次交易），但是你不能同时参与多个交易（即必须在再次购买之前卖出股票）。

编写一个程序，计算你所能获取的最大利润。

示例

输入: [3,3,5,0,0,3,1,4]

输出: 6

解释: 在第4天（股票价格 = 0）的时候买入，在第6天（股票价格 = 3）的时候卖出，这笔交易获得利润 = 3 - 0 = 3 。 然后在第7天（股票价格 = 1）的时候买入，在第8天（股票价格 = 4）的时候卖出，这笔交易获得利润 = 4 - 1 = 3 。

解题思路

为方便理解，我们可以先画一个图。图中的红线代表买入时机，绿线代表卖出时机，矩形表示利润。

1. 状态定义：

定义一个三维数组dp[i][j][k]，表示在第i天，已经交易过j次，当前持股状态为k时的最大利润。

k的状态如下：

• k=0：当前不持股
• k=1：当前持股

2. 状态转移方程：

假设当前是第i天，已经交易过j次，当前不持股，那么dp[i][j][0]的值可以由以下两种情况转移而来：

• 前一天也不持股，即dp[i-1][j][0]，今天不进行任何操作。
• 前一天持股，即dp[i-1][j][1]，今天卖出股票，获得利润prices[i]。

综合以上两种情况，dp[i][j][0]的值为两者中的最大值，即：

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

再假设当前是第i天，已经交易过j次，当前持股，那么dp[i][j][1]的值可以由以下两种情况转移而来：

• 前一天也持股，即dp[i-1][j][1]，今天不进行任何操作。
• 前一天不持股，即dp[i-1][j-1][0]，今天买入股票。

综合以上两种情况，dp[i][j][1]的值为两者中的最大值，即：

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

最终答案为dp[n-1][2][0]，即在最后一天，交易两次且不持股时的最大利润。

时间复杂度：O(n)，其中n为股票价格数组的长度。

代码实现

Python3

from typing import List

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n == 0:
            return 0
        
        # 定义状态数组
        dp = [[[0] * 2 for _ in range(3)] for _ in range(n)]
        
        # 初始化状态
        for i in range(3):
            dp[0][i][0] = 0
            dp[0][i][1] = -prices[0]
        
        # 状态转移
        for i in range(1, n):
            for j in range(3):
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i])
                if j > 0:
                    dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i])
        
        return dp[n-1][2][0]

Java

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if (n == 0) return 0;

        // 定义状态数组
        int[][][] dp = new int[n][3][2];
        
        // 初始化状态
        for (int i = 0; i < 3; i++) {
            dp[0][i][0] = 0;
            dp[0][i][1] = -prices[0];
        }

        // 状态转移
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                dp[i][j][0] = Math.max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                if (j > 0) {
                    dp[i][j][1] = Math.max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
                }
            }
        }

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

C++

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0) {
            return 0;
        }

        // 定义状态数组
        vector<vector<vector<int>>> dp(n, vector<vector<int>>(3, vector<int>(2, 0)));
        
        // 初始化状态
        for (int i = 0; i < 3; i++) {
            dp[0][i][0] = 0;
            dp[0][i][1] = -prices[0];
        }

        // 状态转移
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                if (j > 0) {
                    dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
                }
            }
        }

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

总结

本题是一道动态规划的经典题目，通过定义合适的状态和状态转移方程，可以解决多次买卖股票的问题。在实现时需要注意边界条件和初始化状态。