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

提示：

    1 <= prices.length <= 105
    0 <= prices[i] <= 105

这道题可以使用动态规划的思想来解决。

我们可以先考虑只进行一次交易的情况，用两个数组`buy1`和`sell1`来记录在第i天进行一次交易时的最佳买入和卖出价格。初始化时，`buy1[0] = -prices[0]`表示第一天买入，`sell1[0] = 0`表示第一天不卖出，因为还没有持有股票可以卖出。接下来，我们从第二天开始遍历数组，更新`buy1`和`sell1`数组，具体更新方式如下：

- 对于`buy1[i]`，可以选择不买入，即`buy1[i] = buy1[i-1]`，或者在第i天买入，即`buy1[i] = -prices[i]`和前一天的`sell1[i-1]`二者中的较大值。
- 对于`sell1[i]`，可以选择不卖出，即`sell1[i] = sell1[i-1]`，或者在第i天卖出，即`sell1[i] = prices[i] + buy1[i-1]`和前一天的`sell1[i-1]`二者中的较大值。

然后，我们考虑进行两次交易的情况，用两个数组`buy2`和`sell2`来记录在第i天进行两次交易时的最佳买入和卖出价格。初始化时，`buy2[0] = -prices[0]`和`sell2[0] = buy2[1] = sell2[1] = 0`（因为第一天买入了一次交易，所以第二天不能再买入了）。接下来，我们从第二天开始遍历数组，更新`buy2`和`sell2`数组，具体更新方式如下：

- 对于`buy2[i]`，可以选择不买入，即`buy2[i] = buy2[i-1]`，或者在第i天买入，即`buy2[i] = sell1[i-1] - prices[i]`和前一天的`sell2[i-1]`二者中的较大值。
- 对于`sell2[i]`，可以选择不卖出，即`sell2[i] = sell2[i-1]`，或者在第i天卖出，即`sell2[i] = prices[i] + buy2[i-1]`和前一天的`sell2[i-1]`二者中的较大值。

最终，我们可以得到两次交易的最大利润为`sell2[n-1]`，其中n是数组`prices`的长度。

下面是完整的java代码实现：

 

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

        int[] buy1 = new int[n];
        int[] sell1 = new int[n];
        int[] buy2 = new int[n];
        int[] sell2 = new int[n];

        buy1[0] = -prices[0];
        sell1[0] = 0;
        buy2[0] = -prices[0];
        sell2[0] = 0;
        buy2[1] = -prices[1];

        for (int i = 1; i < n; ++i) {
            buy1[i] = Math.max(buy1[i-1], -prices[i]);
            sell1[i] = Math.max(sell1[i-1], prices[i]+buy1[i-1]);
            buy2[i] = Math.max(buy2[i-1], sell1[i-1]-prices[i]);
            sell2[i] = Math.max(sell2[i-1], prices[i]+buy2[i-1]);
        }

        return sell2[n-1];
    }
}

```

时间复杂度为O(n)，其中n是数组`prices`的长度。另外，上述算法也可以进行状态压缩，只用O(1)的空间复杂度。状态压缩的方法是将四个数组中的每个元素都用变量来表示，从而避免使用数组。下面是状态压缩的java代码实现：

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

        int buy1 = -prices[0], sell1 = 0, buy2 = -prices[0], sell2 = 0;

        for (int i = 1; i < n; ++i) {
            buy1 = Math.max(buy1, -prices[i]);
            sell1 = Math.max(sell1, prices[i]+buy1);
            buy2 = Math.max(buy2, sell1-prices[i]);
            sell2 = Math.max(sell2, prices[i]+buy2);
        }

        return sell2;
    }
}

```

在状态压缩的代码实现中，我们用四个变量`buy1`、`sell1`、`buy2`和`sell2`来分别表示数组`buy1`、`sell1`、`buy2`和`sell2`中的每个元素。这样，就可以避免使用数组，从而将空间复杂度降为O(1)。