最佳买卖股票时机含冷冻期的JAVA动态规划代码实现

package day02;
/*
    给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​
设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
    你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
    卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:
输入: [1,2,3,0,2]
输出: 3
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

 */
public class MaxProfit04 {
    public static void main(String[] args) {
        int [] prices = {1,2,3,0,2};
        //int max = maxProfit(prices);
        int max = maxProfit02(prices);
        System.out.println(max);

    }

    /*
        动态规划方法：找状态-->股票的状态：持有股票0，不持有股票且 处于 冷冻期1，不持有股票且 不处于 冷冻期--》dp[n][3]
        状态转移方程：
        dp[i][0]:第i天持有股票，可以是第i-1天前就持有；也可以是第i天购入 那么第 i−1天就不能持有股票并且不处于冷冻期中
        dp[i][0] = max(dp[i - 1][0],dp[i-1][2] - prices[i])

        dp[i][1]:第 i 天结束之后处于冷冻期的原因是在当天卖出了股票，那么说明在第 i−1天时我们必须持有一支股票
        dp[i][1] = dp[i - 1][0] + prices[i]

        dp[i][2]:第 i 天结束之后不持有任何股票并且不处于冷冻期，说明当天没有进行任何操作，即第 i−1天时不持有任何股票：
        如果处于冷冻期，对应的状态为 dp[i−1][1]；如果不处于冷冻期，对应的状态为 dp[i−1][2]。
        dp[i][2] = max(dp[i - 1][1], dp[i - 1][2])

        初始化状态：dp[0][0] = - prices[0];
                 dp[0][1] = 0;
                 dp[0][2] = 0;
     */
    public static int maxProfit(int [] prices) {
        int len = prices.length;
        if(len < 2) {
            return 0;
        }

        int [][] dp = new int[len][3];
        dp[0][0] = - prices[0];

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

        int max = Math.max(dp[len - 1][1], dp[len - 1][2]);
        return max;
    }

    //优化，由上可以看出，dp[i][...] 只与dp[i - 1][...] 有关， 而与dp[i - 2][...]无关，因此不须存储dp[i - 2][...]的值
    //使用三个变量代替

    public static int maxProfit02(int [] prices) {
        int len = prices.length;
        if(len < 2) {
            return 0;
        }

        int haveStock = -prices[0];
        int freezing = 0;
        int none = 0;

        for(int i = 1; i < len; i ++) {
            int newHaveStock = Math.max(haveStock, none - prices[i]);
            int newFreezing = haveStock + prices[i];
            int newNone = Math.max(freezing,none);

            haveStock = newHaveStock;
            freezing = newFreezing;
            none = newNone;
        }

        return Math.max(freezing,none);
    }
}