最佳买卖股票时机含冷冻期（从暴力 到 记忆化搜索 再到 动态规划）

题目描述

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。​
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

• 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
  注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
  给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格 。​

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

暴力递归

分析： 卖出股票后，你无法在第二天买入股票，所以需要是设置一个标志位来表示当前位置应该买入还是卖出。

	public int maxProfit(int[] prices) {

        return process(prices, 0, 1);
    }

    /**
     * 暴力递归
     *      prices[0···index] 表示已经做过了选择，price[index ···] 表示没有做过选择
     * @param prices    固定参数
     * @param index     数组下标
     * @param flag      标识当前位置能买入还是卖出  （true 标识可以买入，false标识可以卖出）
     * @return
     */
    private int process(int[] prices, int index, int flag) {

        if (index >= prices.length) {
            return 0;
        }
        int in = 0;
        int out = 0;
        if (flag == 1) {
            // 买入
            in = process(prices, index + 1, 0) - prices[index];
        } else {
            // 卖出
            out = process(prices, index + 2, 1) + prices[index];
        }
        // 表示冷冻期
        int stay = process(prices,index + 1, flag);

        return Math.max(Math.max(in,out), stay);
    }

将暴力递归转化为记忆化搜索

分析： 从暴力递归中可以看出有两个变量，分别为index 和 flag，所以应该设置二维dp数组
注意： flag虽是标识位，但是仍然是变量，需要考虑进去。。

	public int maxProfit2(int[] prices) {
        int N = prices.length;
        int [][] dp = new int[N + 2][2];
        for (int i = 0; i < N + 2; i++) {
            for (int j = 0; j < 2; j++) {
                dp[i][j] = -1;
            }
        }
        return process2(prices, 0, 1, dp);
    }

    /**
     * 记忆化搜索
     *      prices[0···index] 表示已经做过了选择，price[index ···] 表示没有做过选择
     * @param prices    固定参数
     * @param index     数组下标
     * @param flag      标识当前位置能买入还是卖出  （true 标识可以买入，false标识可以卖出）
     * @return
     */
    private int process2(int[] prices, int index, int flag, int[][] dp) {

        if (dp[index][flag] != -1) {
            return dp[index][flag];
        }
        if (index >= prices.length) {
            dp[index][flag] = 0;
            return dp[index][flag];
        }
        int in = 0;
        int out = 0;
        if (flag == 1) {
            // 买入
            in = process2(prices, index + 1, 0, dp) - prices[index];
        } else {
            // 卖出
            out = process2(prices, index + 2, 1, dp) + prices[index];
        }
        // 冷冻期
        int stay = process2(prices,index + 1, flag, dp);

        dp[index][flag] = Math.max(Math.max(in, out), stay);
        return dp[index][flag];
    }

将暴力搜索更改为动态规划

	/**
     * 动态规划
     * @param prices
     * @return
     */
    public int dpWay(int[] prices) {
        int N = prices.length;
        int[][] dp = new int[N + 2][2];
        for (int i = N - 1; i >= 0; i--) {
            for (int j = 1; j >= 0; j--) {
                int in = 0;
                int out = 0;
                if (j == 1) {
                    in = dp[i + 1][0] - prices[i];
                } else {
                    out = dp[i + 2][1] + prices[i];
                }
                int stay = dp[i + 1][j];

                dp[i][j] = Math.max(Math.max(in, out), stay);
            }
        }
        return dp[0][1];
    }

结果：

暴力递归超时，剩下两种方法ac