买卖股票的最佳时机Ⅳ

力扣：188. 买卖股票的最佳时机 IV - 力扣（LeetCode）
给定一个整数数组 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 <= 100
0 <= prices.length <= 1000
0 <= prices[i] <= 1000

这道题⽬可以说是动态规划：123.买卖股票的最佳时机III的进阶版，这⾥要求⾄多有k次交易。相信看懂了上一篇文章的朋友是完全有能力解决这一题的。

动规五部曲：

1. 确定dp数组以及下标的含义

在动态规划：买卖股票的最佳时机III中，定义了⼀个⼆维dp数组，本题其实依然可以⽤⼀个⼆维dp数组。使⽤⼆维数组 dp[i][j] ：第i天的状态为j，所剩下的最⼤现⾦是dp[i][j]
j的状态表示为：
0 表示不操作
1 第⼀次买⼊
2 第⼀次卖出
3 第⼆次买⼊
4 第⼆次卖出
.....
⼤家应该发现规律了吧，除了0以外，偶数就是卖出，奇数就是买⼊。题⽬要求是⾄多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。所以⼆维dp数组的C++定义为：

        int[][] dp = new int[l][k * 2 + 1];

2. 确定递推公式

还要强调⼀下：dp[i][1]，表示的是第i天，买⼊股票的状态，并不是说⼀定要第i天买⼊股票，这是很多同学容易陷⼊的误区。
达到dp[i][1]状态，有两个具体操作：
操作⼀：第i天买⼊股票了，那么dp[i][1] = dp[i - 1][0] - prices[i]
操作⼆：第i天没有操作，⽽是沿⽤前⼀天买⼊的状态，即：dp[i][1] = dp[i - 1][1]
选最⼤的，所以 dp[i][1] = max(dp[i - 1][0] - prices[i], dp[i - 1][0]);
同理dp[i][2]也有两个操作：
操作⼀：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
操作⼆：第i天没有操作，沿⽤前⼀天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]
所以dp[i][2] = max(dp[i - 1][i] + prices[i], dp[i][2])
同理可以类⽐剩下的状态，代码如下：

            for(int j = 1; j < 2 * k; j += 2){
                dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - 1] - prices[i]);
                dp[i][j + 1] = Math.max(dp[i - 1][j + 1], dp[i - 1][j] + prices[i]);
            }

本题和动态规划：123.买卖股票的最佳时机III最⼤的区别就是这⾥要类⽐j为奇数是买，偶数是卖剩的状态

3. dp数组如何初始化

第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第⼀次买⼊的操作，dp[0][1] = -prices[0];
第0天做第⼀次卖出的操作，这个初始值应该是多少呢？
⾸先卖出的操作⼀定是收获利润，整个股票买卖最差情况也就是没有盈利即全程⽆操作现⾦为0，
从递推公式中可以看出每次是取最⼤值，那么既然是收获利润如果⽐0还⼩了就没有必要收获这个利润了。所以dp[0][2] = 0;
第0天第⼆次买⼊操作，初始值应该是多少呢？
不⽤管第⼏次，现在⼿头上没有现⾦，只要买⼊，现⾦就做相应的减少。
第⼆次买⼊操作，初始化为：dp[0][3] = -prices[0];
所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]
代码如下：

      for(int i = 1; i < 2 * k; i += 2)
            dp[0][i] = -prices[0];

4. 确定遍历顺序

从递归公式其实已经可以看出，⼀定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

5. 举例推导dp数组

以输⼊[1,2,3,4,5]，k=2为例。

最后⼀次卖出，⼀定是利润最⼤的，dp[prices.size() - 1][2 * k]即红⾊部分就是最后求解。
以上分析完毕，java代码如下：

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

动态规划问题买卖股票的最佳时机问题04：买卖股票的最佳时机Ⅳ