188. 买卖股票的最佳时机 IV

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iv
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

动态规划（方法一）

class Solution {

    private int all(int[] prices) {
        int ret = 0;

        for (int i = 1; i < prices.length; ++i) {
            if (prices[i] > prices[i - 1]) {
                ret += prices[i] - prices[i - 1];
            }
        }
        return ret;
    }

    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        if (k >= n / 2) {
            return all(prices);
        }

        /**
         * dp[i][j] =
         * dp[i - 1][j]
         * dp[i][j-1] - prices[i] + prices[i]
         * dp[i-1][j-1] - prices[i-1] + prices[i]
         * dp[0][j-1] - prices[0] + prices[i]
         *
         */
        int[][] dp = new int[n][k + 1];

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

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

        return dp[n - 1][k];
    }

    public static void main(String[] args) {
        int k = 2;
        int[] prices = {3, 2, 6, 5, 0, 3};
        System.out.println(new Solution().maxProfit(k, prices));
    }
}

动态规划（方法二）

import java.util.Arrays;

class Solution {

    private int all(int[] prices) {
        int ret = 0;

        for (int i = 1; i < prices.length; ++i) {
            if (prices[i] > prices[i - 1]) {
                ret += prices[i] - prices[i - 1];
            }
        }
        return ret;
    }

    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        if (k >= n / 2) {
            return all(prices);
        }
        int[][] hold = new int[n][k + 1];
        int[][] noHold = new int[n][k + 1];

        hold[0][0] = -prices[0];

        for (int i = 1; i < n; ++i) {
            hold[i][0] = Math.max(hold[i - 1][0], -prices[i]);
        }

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

        for (int i = 1; i < n; ++i) {
            for (int j = 1; j <= k; ++j) {
                hold[i][j] = Math.max(hold[i - 1][j], noHold[i - 1][j] - prices[i]);
                noHold[i][j] = Math.max(noHold[i - 1][j], hold[i - 1][j - 1] + prices[i]);
            }
        }

        return Arrays.stream(noHold[n - 1]).max().getAsInt();

    }
}

方法二

与方法二定义一次交易不同，相应的状态转移方程也不同

import java.util.Arrays;

class Solution {

    private int all(int[] prices) {
        int ret = 0;

        for (int i = 1; i < prices.length; ++i) {
            if (prices[i] > prices[i - 1]) {
                ret += prices[i] - prices[i - 1];
            }
        }
        return ret;
    }

    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        if (k >= n / 2) {
            return all(prices);
        }
        int[][] hold = new int[n][k + 1];
        int[][] noHold = new int[n][k + 1];

        for (int i = 0; i < n; ++i) {
            hold[i][0] = Integer.MIN_VALUE;
        }

        for (int j = 1; j <= k; ++j) {
            hold[0][j] = -prices[0];
        }

        for (int i = 1; i < n; ++i) {
            for (int j = 1; j <= k; ++j) {
                hold[i][j] = Math.max(hold[i - 1][j], noHold[i - 1][j - 1] - prices[i]);
                noHold[i][j] = Math.max(noHold[i - 1][j], hold[i - 1][j] + prices[i]);
            }
        }

        return Arrays.stream(noHold[n - 1]).max().getAsInt();
    }
}

动态规划（方法二的空间压缩）

import java.util.Arrays;

class Solution {

    private int all(int[] prices) {
        int ret = 0;

        for (int i = 1; i < prices.length; ++i) {
            if (prices[i] > prices[i - 1]) {
                ret += prices[i] - prices[i - 1];
            }
        }
        return ret;
    }

    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length == 0) {
            return 0;
        }

        int n = prices.length;
        if (k >= n / 2) {
            return all(prices);
        }
        int[] hold = new int[k + 1];
        int[] noHold = new int[k + 1];

        hold[0] = -prices[0];

        for (int i = 1; i <= k; ++i) {
            hold[i] = Integer.MIN_VALUE / 2;
        }

        for (int i = 1; i < n; ++i) {
            int preHold = hold[0];
            hold[0] = Math.max(hold[0], -prices[i]);
            for (int j = 1; j <= k; ++j) {
                int tmp = hold[j];
                hold[j] = Math.max(hold[j], noHold[j] - prices[i]);
                noHold[j] = Math.max(noHold[j], preHold + prices[i]);
                preHold = tmp;
            }
        }

        return Arrays.stream(noHold).max().getAsInt();

    }
}