动态规划——买卖股票的最佳时机 Ⅳ

问题来源：leetcode 188。

买卖股票的最佳时机 Ⅳ

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

提示：

• 0 <= k <= 10^9
• 0 <= prices.length <= 1000
• 0 <= prices[i] <= 1000

动态规划

优化子结构：设 $dp[i][j][0]$ 表示第 $i$ 天结束时，恰好参与了 $j$ 笔交易，且手里没有股票的最大利润；设 $dp[i][j][1]$ 表示第 $i$ 天结束时，恰好参与了 $j$ 笔交易，且手中持有股票的最大利润。规定买入股票就算是一次交易的开始，卖出股票时交易次数不会再增加。
首先分析原问题的最优解 $dp[i][j][0]$ 是如何包含子问题的最优解的，或者说 $dp[i][j][0]$ 是如何用子问题的最优解来构造的：

• 如果前一天手中没有股票（子问题一），那么 $dp[i][j][0]$ 便是该子问题 “第 $i-1$ 天结束，恰好参与了 $j$ 笔交易，且手中没有股票” 的最优解，即 $dp[i][j][0]=dp[i-1][j][0]$，也就是说只需要求解子问题 $dp[i-1][j][0]$。可以通过反证法来证明：假设 $dp[i-1][j][0]$ 不是其自身子问题的最优解，而是存在一个更优的解 $d{p}^{{}^{\prime }}[i-1][j][0]$，那么由于第 $i-1$ 天没有股票，第 $i$ 天也没有股票，那么第 $i$ 天肯定没有进行股票买卖，所以会产生原问题的一个更优的解 $d{p}^{{}^{\prime }}[i-1][j][0]$，与 $dp[i][j][0]=dp[i-1][j][0]$ 是原问题的最优解矛盾。所以在前一天也没有股票的情况话，可以直接由子问题的最优解来构造原问题的最优解。
• 如果前一天手中持有股票（子问题二），那么 $dp[i][j][0]-prices[i]$ 便是该子问题 “第 $i-1$ 天结束，恰好参与了 $j$ 次交易，且手中持有股票” 的最优解，也就是说只需要求解子问题。同样可以通过反证法来证明，略。

接下来分析 $dp[i][j][1]$ 是如何包含子问题的最优解的：

• 如果前一天手中持有股票（子问题一），那么 $dp[i][j][1]$ 便是该子问题的最优解，即 $dp[i][j][1]=dp[i-1][j][1]$，即只需要求解子问题 $dp[i-1][j][1]$。
• 如果前一天手中没有股票（子问题二），那么 $dp[i][j][1]+prices[i]$ 表示该子问题的最优解，即 $dp[i][j][1]=dp[i-1][j][0]-prices[i]$，只需要求解子问题 $dp[i-1][j][0]$。

以上分析说明该问题具有优化子结构，

重叠子问题：举例说明，计算 $dp[i][j][0]$ 和 $dp[i][j][1]$ 时，都需要用到子问题 $dp[i-1][j][1]$ 的解，即存在重叠子问题。

递归地定义最优解的值：初始化 $dp$ 数组的大小为 $n\ast (k+1)\ast 2$，初始化 $dp[0][j][0]=0$，$dp[0][j][1]=-prices[0]$，当 $i>1$ 时，对于 $j$ 的每个取值：
$$dp[i][j][0]=\{\begin{array}{cc}0& j=0||i=0\\ max(dp[i-1][j][0],dp[i-1][j][1]+prices[i])& i>0,j>0\end{array}$$

$$dp[i][j][1]=\{\begin{array}{cc}0& j=0\\ -prices[0]& i=0\\ max(dp[i-1][j][1],dp[i-1][j-1][0]-prices[i])& i>0,j>0\end{array}$$
注意可以同一天同时买入并卖出，这样就算一笔交易，但是收益为 0，所以在第一天时（ $i=0$），无论 $j$ 取多少，我们都可以完成这么多次交易，$dp[0][j][0]=0$；也可以前 $j-1$ 次买入并同时卖出，第 $j$ 次买入不卖出，这样就是 $dp[0][j][1]=-prices[0]$。

自底向上地计算最优解的值：从前向后遍历 $prices$ 数组，对于该数组的每一个位置，为每个可能的交易次数填充此时手中是否持有股票的最大利润，这样在计算每一个 $dp[i][j][k]$ 时，都可以保证其相关的子问题都已经被计算过且保存在数组中了。

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

        vector<vector<vector<int>>> dp(n, vector<vector<int>>(k+1, vector<int>(2)));
        for(int j=1; j<=k; j++) {
            dp[0][j][1] = -prices[0];
        }

        for(int i=1; i<n; i++) {
            for(int j=1; j<=k; j++) {
                dp[i][j][0] = max(dp[i-1][j][0], dp[i-1][j][1] + prices[i]);
                dp[i][j][1] = max(dp[i-1][j][1], dp[i-1][j-1][0] - prices[i]);
            }
        }
        
        return dp[n-1][k][0];
    }
};

做空间优化：注意到每个 $dp[i][...][...]$ 仅与 $dp[i-1][...][...]$ 相关，所以可以仅维护一个二维数组，而不再是维护三维数组。
关于这里 $j$ 是正序还是倒序，可以参考。

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

        vector<vector<int>> dp(k+1, vector<int>(2));
        for(int j=1; j<=k; j++) {
            dp[j][1] = -prices[0];
        }

        for(int i=1; i<n; i++) {
            for(int j=1; j<=k; j++) {
                dp[j][0] = max(dp[j][0], dp[j][1] + prices[i]);
                dp[j][1] = max(dp[j][1], dp[j-1][0] - prices[i]);
            }
        }
        
        return dp[k][0];
    }
};