数据结构 -- 6种股票交易

一、穷举框架
利用「状态」进行穷举。我们具体到每一天，再找出每个「状态」对应的「选择」。
股票问题每天有三种「选择」：买入、卖出、无操作，用 buy, sell, rest 表示这三种选择

这个问题的「状态」有三个，第一个是天数，第二个是允许交易的最大次数，第三个是当前的持有状态（即之前说的 rest 的状态，假设 1 表示持有，0 表示没有持有）。

dp[i][k][0 or 1]

for 0 <= i < n:
    for 1 <= k <= K:
        for s in {0, 1}:
            dp[i][k][s] = max(buy, sell, rest)

想求的答案是 dp[n - 1][K][0]，即最后一天，最多允许 K 次交易，最多获得多少利润。

二、状态转移框架
状态转移图：

状态转移方程：
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])
初始值：
dp[-1][k][0] = dp[i][0][0] = 0
dp[-1][k][1] = dp[i][0][1] = -infinity

三、6种题型

第一题，k = 1

化简后状态转移方程：
dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
dp[i][1] = max(dp[i-1][1], -prices[i])
直接写出代码：

int maxProfit_k_1(int[] prices) {
    int n = prices.length;
    int dp_i0 = 0, dp_i1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        dp_i0 = Math.max(dp_i0, dp_i1 + prices[i]);
        dp_i1 = Math.max(dp_i1, -prices[i]);
    }
    return dp_i0;
}

第二题，k = +infinity

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

直接翻译成代码：

int maxProfit_k_inf(int[] prices) {
    int n = prices.length;
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        int temp = dp_i_0;
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = Math.max(dp_i_1, temp - prices[i]);
    }
    return dp_i_0;
}

第三题，k = +infinity with cooldown：每次 sell 之后要等一天才能继续交易。

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

翻译成代码：

int maxProfit_with_cool(int[] prices) {
    int n = prices.length;
    int dp_i0 = 0, dp_i1 = Integer.MIN_VALUE;
    int dp_pre0 = 0;   // 代表 dp[i-2][0]
    for (int i = 0; i < n; i++) {
        int temp = dp_i0;
        dp_i0 = Math.max(dp_i0, dp_i1 + prices[i]);
        dp_i1 = Math.max(dp_i1, dp_pre0 - prices[i]);
        dp_pre0 = temp;
    }
    return dp_i0;
}

第四题，k = +infinity with fee

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

直接翻译成代码：

int maxProfit_with_fee(int[] prices, int fee) {
    int n = prices.length;
    int dp_i_0 = 0, dp_i_1 = Integer.MIN_VALUE;
    for (int i = 0; i < n; i++) {
        int temp = dp_i_0;
        dp_i_0 = Math.max(dp_i_0, dp_i_1 + prices[i]);
        dp_i_1 = Math.max(dp_i_1, temp - prices[i] - fee);
    }
    return dp_i_0;
}

第五题，k = 2

原始的动态转移方程，没有可化简的地方
dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i])
dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i])

因为k = 2， 所以直接翻译成代码：
dp[i][2][0] = max(dp[i-1][2][0], dp[i-1][2][1] + prices[i])
dp[i][2][1] = max(dp[i-1][2][1], dp[i-1][1][0] - prices[i])
dp[i][1][0] = max(dp[i-1][1][0], dp[i-1][1][1] + prices[i])
dp[i][1][1] = max(dp[i-1][1][1], -prices[i])

int maxProfit_k_2(int[] prices) {
    int dp_i10 = 0, dp_i11 = Integer.MIN_VALUE;
    int dp_i20 = 0, dp_i21 = Integer.MIN_VALUE;
    for (int price : prices) {
        dp_i20 = Math.max(dp_i20, dp_i21 + price);
        dp_i21 = Math.max(dp_i21, dp_i10 - price);
        dp_i10 = Math.max(dp_i10, dp_i11 + price);
        dp_i11 = Math.max(dp_i11, -price);
    }
    return dp_i20;
}

第六题，k = any integer

• 当k > len / 2 时，可在一定程度上说明 k 趋于无穷，即可同化为第二种情况
• 当k < len / 2 时，则k值大小会对结果产生影响，可采用最原始的状态转移方程。

为什么以 len / 2为分界线？

个人理解： 当 k 小于分界线时，可进行 k 次交换，但当 k 大于分界限时，无法完成 k 次交换，在一定程度上也说明k值对其无影响。

int maxProfit_k_any(int max_k, int[] prices) {
    int n = prices.length;
    if (max_k > n / 2) 
        return maxProfit_k_inf(prices);

    int[][][] dp = new int[n][max_k + 1][2];
    for (int i = 0; i < n; i++) 
        for (int k = max_k; k >= 1; k--) {
            if (i - 1 == -1) { /* 处理 base case */ }
            dp[i][k][0] = max(dp[i-1][k][0], dp[i-1][k][1] + prices[i]);
            dp[i][k][1] = max(dp[i-1][k][1], dp[i-1][k-1][0] - prices[i]);     
        }
    return dp[n - 1][max_k][0];
   }
``