leetcode-买卖股票的最佳时机 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 。

1. 递归

通过递归遍历所有的情况
每次进入函数时有三个参数:

i -> 天数
left 剩余交易次数
have 当前是否持有股票

class Solution {
     public int maxProfit(int[] prices) {
       return deep(prices, 0, 2, false);
    }

    private int deep(int[] prices, int i, int left, boolean have) {
        if (i >= prices.length || left <= 0) {
            return 0;
        }
        if (!have) {
            return Math.max(
                deep(prices, i + 1, left, true) - prices[i],
                deep(prices, i + 1, left, false)
            );
        } else {
            return Math.max(
              deep(prices, i + 1, left - 1 , false) + prices[i] ,
                deep(prices, i + 1, left , true)
            );
        }
    }
}

2. 递归优化

上面递归存在冗余的计算 & 且多层函数嵌套 会超时 通过循环代替递归如下

dpa[i][j][k] 代表 在第i天时还剩j次交易次数当前持有k支股票的情况下能获得的最大收益

class Solution {
      public int maxProfit(int[] prices) {
      // return deep(prices, 0, 2, false);
        return dp(prices);
    }

    private int dp(int[] prices) {
	
        int [][][] dpa = new int[prices.length + 1][3][2];

        for (int j = 0; j < 3; j++) {
            for (int k = 0; k < 2; k++) {
                dpa[prices.length][j][k] = 0;
            }
        }

        for (int i = prices.length - 1; i >=  0; i--) {
            for (int j = 0; j < 3; j++) {
                for (int k = 0; k < 2; k++) {
                    if (j == 0) {
                        dpa[i][j][k] = 0;
                        continue;
                    }
                    if (k == 0) {
                        dpa[i][j][k] = Math.max(
                          dpa[i + 1][j][1] - prices[i],
                          dpa[i + 1][j][0]
                        );
                    } else {
                        dpa[i][j][k] = Math.max(
                            dpa[i + 1][j - 1][0] + prices[i],
                            dpa[i + 1][j][1]
                        );
                    }
                }
            }
        }

        return dpa[0][2][0];
    }
}