买卖股票的最佳时机III--LeetCode123

买卖股票的最佳时机III–LeetCode123

题目

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

思路

这道题相比较之前买卖股票I和II，限制的地方是在最多可以完成两笔交易。自己一开始的思路是求出收益第一高和第二高的两个利润，最后相加，这样的想法不完全正确。反例：对于[1,2,3,4,5]，上述方法求出来最大利润是2，实际上是4；对于[1,5,2,8,3,10]，求出来的结果是(8-2)+(10-3)=13，但实际上最大利润是(8-1)+(10-3) = 14。因此必须用动态规划的思想来做。

以下的思路参考了windliang的题解 ，结合了自己的理解。

dp数组的含义
用 dp[i][k]表示前i天（包括第i天）最多交易k次的最高利润。

状态转移方程
第i天有两种情况：

• 如果第 i天什么都不操作，那么这一天的最高收益就等于前一天的最高收益，即dp[i][k] = dp[i-1][k]。
• 为了获得最大利润，第 i天不可能买入，因为买入会使利润降低。如果第 i天选择卖出，在0到 i-1天就要选择一天买入。这就构成了一次交易，那么在买入之前就已经进行了 k-1次交易。

上述第二种情况中，要在0到 i-1天选择一天买入，假如在第 j天买入，收益就是 prices[i] - prices[j] + dp[j-1][k-1]，最后一项是j前一天的最大收益。因为在同一天买入和卖出对收益是没有影响的，所以也可以改成加上第j天当天的最大收益，收益就是 prices[i] - prices[j] + dp[j][k-1]。在0到 i-1天选择一天买入，找到哪一天买入使得收益最大，然后与第i天什么都不操作比较，就是dp[i][k]的值了。

dp[i][k] = Max(dp[i-1][k], prices[i] - prices[j] + dp[j][k-1])，j 取 0,...,i

dp数组二维信息示意图如下：

代码如下：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int K = 2;
        int[][] dp = new int[prices.length][K+1];
        // 固定k,对二维数组一列一列进行更新，更新的思路就是上述分析的思路
        for (int k = 1; k <= K; k++) {
            for (int i = 1; i < prices.length; i++) {
                int min = Integer.MAX_VALUE;
                // 找出0 到 i-1 天中prices[j]-dp[j][k-1]的最小值
                for (int j = 0; j < i; j++) {
                    min = Math.min(min, prices[j]-dp[j][k-1]);
                }
				// 比较不操作和选择一天买入的哪个值更大
                dp[i][k] = Math.max(dp[i-1][k], prices[i]-min);
            }
        }
        return dp[prices.length-1][K];
    }
}

时间超慢，因为每次都要找出0 到 i-1天中prices[j]-dp[j][k-1]的最小值。使用额外的空间来存储第 1 天到第i天 prices[i]-dp[i][k-1]的最小值，对时间复杂度进行优化。此时是一行一行对二维数组进行更新。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int K = 2;
        int[][] dp = new int[prices.length][K+1];
        int[] min = new int[K+1];
        // 初始化，因为下面的两层for循环是从第二天开始考虑的，所以这里的最小值数组初始化为第一天的价格
        for (int i = 1; i <= K; i++) {
            min[i] = prices[0];
        }
        for (int i = 1; i < prices.length; i++) {
            for (int k = 1; k <= K; k++) {
                // 找出第 1 天到第 i 天 prices[i]-dp[i][k-1] 的最小值
                min[k] = Math.min(prices[i]-dp[i][k-1], min[k]);
                // 比较不操作和选择一天买入的哪个值更大
                dp[i][k] = Math.max(dp[i-1][k], prices[i]-min[k]);
            }
        }
        return dp[prices.length-1][K];
    }
}

对空间进一步优化，dp数组使用一维数组即可。

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }
        int K = 2;
        int[] dp = new int[K+1];
        int[] min = new int[K+1];
        for (int i = 1; i <= K; i++) {
            min[i] = prices[0];
        }
        for (int i = 1; i < prices.length; i++) {
            for (int k = 1; k <= K; k++) {
                min[k] = Math.min(prices[i]-dp[k-1], min[k]);
                dp[k] = Math.max(dp[k], prices[i]-min[k]);
            }
        }
        return dp[K];
    }
}