L188买卖股票的最佳时机 IV

给定一个整数数组 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次交易
即更为一般的规律。

	for(int i = 1; i < len; i++){
            dp[i][1][1] = Math.max(dp[i - 1][1][1], -prices[i]);
            //交易一次，且当前持股，可以上次相同状态转化而来，或者当前第一次买入
            dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i]);
            //交易一次，当前不持股：延续上次状态，或者上次买入现在卖出
            dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]);
            //交易两次，当前持股：延续上次状态，或者第一次卖出，但有利润累计，这次再次买入
            //注意需要参考dp[i - 1][2][1],若为dp[1][2][1]，需参考dp[0][2][0],这里设为最小值
            //,就是防止被参考到，因为才第二次，不可能交易两次
            dp[i][2][0] = Math.max(dp[i - 1][2][0], dp[i - 1][2][1] + prices[i]);
            //交易两次，当前不持股：延续上次状态，或者第一次买入，这次卖出
            //若为dp[1][2][0]，需参考dp[0][2][1],这里设为最小值,同样防止被参考
        }

对比一下核心代码即可知道，可以换为一般形式，
dp[i][1][1] = Math.max(dp[i - 1][1][1], -prices[i]);这个需要换一下形式为，dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]);
由于涉及到j-1或者i-1，扩展一下数组范围，统一+1比较好

若想提前初始化一下，其实无法实现，首先k的取值不确定，k 若小于2，则运行时错误，越界，还是整体初始化比较好

public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        // 特殊判断
        if (k == 0 || len < 2) {
            return 0;
        }
        // 特殊判断，因为交易一次需要 2 天，如果 k >= len / 2，相当于没有限制
        // 转换为「力扣」第 122 题，使用贪心算法
        if (k >= len / 2) {
            return greedy(prices, len);
        }


        int[][][] dp = new int[len + 1][k + 1][2];

        // 初始化：把持股的部分都设置为一个较小的负值
        // 注意：如果使用默认值 0，状态转移的过程中会做出错误的决策
        for(int i = 0; i <= len; i++){
            for(int j = 0; j <= k;j++){
                dp[i][j][1] = Integer.MIN_VALUE;
            }
        }

        // 注意：i 和 j 都有 1 个位置的偏移
        for (int i = 1; i <= len; i++) {
            for (int j = 1; j <= k; j++) {
                //注意prices对应的下标为i - 1
                dp[i][j][1] = Math.max(dp[i - 1][j][1], dp[i - 1][j - 1][0] - prices[i - 1]);
                //要么状态保持不变，或者上次不持股，现在买入
                dp[i][j][0] = Math.max(dp[i - 1][j][0], dp[i - 1][j][1] + prices[i - 1]);
                //要么状态保持不变,或者上次持股的累计值，现在抛出。
                //注意与上面的区别在于 dp[i - 1][j][1]，注意下标不是j -1;
            }
        }
        // 说明：第一维和第二维状态都具有前缀性质的，输出最后一个状态即可
        //只是表示一个状态，但我觉得k(0-k-1)都对比一下更稳妥
        return dp[len][k][0];
    }

    private int greedy(int[] prices, int len) {
        // 转换为股票系列的第 2 题，使用贪心算法完成，思路是只要有利润，就交易
        int res = 0;
        for (int i = 1; i < len; i++) {
            if (prices[i] > prices[i - 1]) {
                res += prices[i] - prices[i - 1];
            }
        }
        return res;
    }

2.缩小一下空间

public int maxProfit(int k, int[] prices) {
        int len = prices.length;
        // 特殊判断
        if (k == 0 || len < 2) {
            return 0;
        }
        // 特殊判断，因为交易一次需要 2 天，如果 k >= len / 2，相当于没有限制
        // 转换为「力扣」第 122 题，使用贪心算法
        if (k >= len / 2) {
            return greedy(prices, len);
        }


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

        for(int i = 0; i <= k; i++){
            dp[i][1] = Integer.MIN_VALUE;
        }

        for(int price : prices){
            for(int i = 1; i <= k; i++){
                //因为从头开始，可以直接参考本身
                dp[i][1] = Math.max(dp[i][1], dp[i - 1][0] - price);
                //dp[i][0] = Math.max(dp[i][0], dp[i - 1][1] + price);
                //注意这里不一样,为dp[i][1] + price，因为要参考的是相同k的状态
                dp[i][0] = Math.max(dp[i][0], dp[i][1] + price);
            }
        }

        return dp[k][0];
    }

    private int greedy(int[] prices, int len) {
        // 转换为股票系列的第 2 题，使用贪心算法完成，思路是只要有利润，就交易
        int res = 0;
        for (int i = 1; i < len; i++) {
            if (prices[i] > prices[i - 1]) {
                res += prices[i] - prices[i - 1];
            }
        }
        return res;
    }