算法Day35|动态规划专题七 121. 买卖股票的最佳时机，122.买卖股票II，123.买卖股票III，188.买卖股票IV，714.买卖股票含手续费， 309. 买卖股票含冷冻期

121. 买卖股票的最佳时机

1.题目描述

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0

2.解题思路

动规五部曲：

确定dp数组以及下标的含义
确定递推公式
dp数组如何初始化
确定遍历顺序
举例推导dp数组

1.确定dp数组以及下标的含义
dp[i][0] 表示第i天持有股票所得最多现金
dp[i][1] 表示第i天不持有股票所得最多现金
注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
2.确定递推公式
如果第i天持有股票即dp[i][0]，可以由两个状态推出来
第i-1天就持有股票，那么就保持现状，所得现金就是昨天持有股票的所得现金即：dp[i - 1][0]
第i天买入股票，所得现金就是买入今天的股票后所得现金即：-prices[i]
dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);

如果第i天不持有股票即dp[i][1]，也可以由两个状态推出来

第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金即：dp[i - 1][1]
第i天卖出股票，所得现金就是按照今天股票佳价格卖出后所得现金即：prices[i] + dp[i - 1][0]

同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);

3.dp数组如何初始化
那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;

4.确定遍历顺序
从递推公式可以看出dp[i]都是有dp[i - 1]推导出来的，那么一定是从前向后遍历。
5.举例推导dp数组
以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：

121.买卖股票的最佳时机

3.代码实现

class Solution {
    //121. 买卖股票的最佳时机
    public int maxProfit(int[] prices) {
        //dp[i][0]:第i天持有股票所得现金
        //dp[i][1]:第i天不持有股票所得现金
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < prices.length; i++) {
            //第i天持有股票dp[i][0]:
                //情况1：i-1天就持有股票 dp[i - 1][0]
                //情况2：i-1天不持有股票,第i天买入 -prices[i]
            dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
            //第i天不持有股票 dp[i][1]:
                //情况1：i-1天就不持有股票 dp[i - 1][1]
                //情况2：i-1天就持有股票,第i天卖出 dp[i - 1][0]+prices[i]
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[prices.length - 1][1];
    }
}

122.买卖股票的最佳时机II

1.题目描述

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。
返回你能获得的最大利润。

2.解题思路

注意这里和121. 买卖股票的最佳时机 (opens new window)唯一不同的地方，就是推导dp[i][0]的时候，第i天买入股票的情况。
在121. 买卖股票的最佳时机 (opens new window)中，因为股票全程只能买卖一次，所以如果买入股票，那么第i天持有股票即dp[i][0]一定就是 -prices[i]。
而本题，因为一只股票可以买卖多次，所以当第i天买入股票的时候，所持有的现金可能有之前买卖过的利润。
那么第i天持有股票即dp[i][0]，如果是第i天买入股票，所得现金就是昨天不持有股票的所得现金减去今天的股票价格即：dp[i - 1][1] - prices[i]。

3.代码实现

class Solution {
  //122.买卖股票的最佳时机II
    public int maxProfit(int[] prices) {
       //dp[i][0]:第i天持有股票所得现金
        //dp[i][1]:第i天不持有股票所得现金
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < prices.length; i++) {
            //第i天持有股票dp[i][0]:
            //情况1：i-1天就持有股票 dp[i - 1][0]
            //情况2：i-1天不持有股票,第i天买入 dp[i - 1][1] - prices[i]（与121唯一不同的地方）
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            //第i天不持有股票 dp[i][1]:
            //情况1：i-1天就不持有股票 dp[i - 1][1]
            //情况2：i-1天就持有股票,第i天卖出 dp[i - 1][0]+prices[i]
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]);
        }
        return dp[prices.length - 1][1];
    }
}

123.买卖股票的最佳时机III

1.题目描述

给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成两笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

2.解题思路

1.确定dp数组以及下标的含义
这道题目相对 121.买卖股票的最佳时机 (opens new window)和 122.买卖股票的最佳时机II (opens new window)难了不少。
关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
接来下我用动态规划五部曲详细分析一下：
确定dp数组以及下标的含义
一天一共就有五个状态，
没有操作
第一次买入
第一次卖出
第二次买入
第二次卖出
dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。

    //123.买卖股票的最佳时机III
    public int maxProfit(int[] prices) {
        //dp[i][j]:i表示第i天，j为[0-4]五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        //0没有操作，1第一次买入，2第一次卖出
        //3第二次买入，4第二次卖出
        int[][] dp = new int[prices.length][5];
    }

2.确定递推公式

达到dp[i][1]状态，有两个具体操作：

操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？

一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

同理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][1] + prices[i], dp[i - 1][2])

同理可推出剩下状态部分：

dp[i][3] = max(dp[i - 1][3], dp[i - 1][2] - prices[i]);

dp[i][4] = max(dp[i - 1][4], dp[i - 1][3] + prices[i]);

3.dp数组如何初始化
第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，这个初始值应该是多少呢？
首先卖出的操作一定是收获利润，整个股票买卖最差情况也就是没有盈利即全程无操作现金为0，
从递推公式中可以看出每次是取最大值，那么既然是收获利润如果比0还小了就没有必要收获这个利润了。
所以dp[0][2] = 0;
第0天第二次买入操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？
第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后在买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0;

4.确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]依靠dp[i - 1]的数值。。
5.举例推导dp数组
以输入[1,2,3,4,5]为例

123.买卖股票的最佳时机III

3.代码实现

class Solution {
   //123.买卖股票的最佳时机III
    public int maxProfit(int[] prices) {
        //dp[i][j]:i表示第i天，j为[0-4]五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        //0没有操作，1第一次买入，2第一次卖出
        //3第二次买入，4第二次卖出
        int[][] dp = new int[prices.length][5];
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;
        for (int i = 1; i < prices.length; i++) {
            //j=1：第一次买入
            //dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票
            //情况1：第i天之前已经买入 dp[i - 1][1]
            //情况2：第i天买入 dp[i - 1][0] - prices[i]
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
            //j=2：第一次卖出
            //情况1：第i天之前已经卖出 dp[i - 1][2]
            //情况2：第i天卖出 dp[i - 1][1] + prices[i]
            dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
            //j=3：第二次买入
            //情况1：第i天之前已经买入 dp[i - 1][3]
            //情况2：第i天买入 dp[i - 1][2] - prices[i]
            dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
            //j=4：第二次卖出
            //情况1：第i天之前已经卖出 dp[i - 1][4]
            //情况2：第i天卖出 dp[i - 1][3] + prices[i]
            dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
        }
        return dp[prices.length - 1][4];
    }
}

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

1.题目描述

给定一个整数数组 prices ，它的第 i 个元素 prices[i] 是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

2.解题思路

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

在动态规划：123.买卖股票的最佳时机III (opens new window)中，我是定义了一个二维dp数组，本题其实依然可以用一个二维dp数组。

使用二维数组 dp[i][j] ：第i天的状态为j，所剩下的最大现金是dp[i][j]

确定dp数组以及下标的含义
没有操作
第一次买入
第一次卖出
第二次买入
第二次卖出
大家应该发现规律了吧，除了0以外，偶数就是卖出，奇数就是买入。
题目要求是至多有K笔交易，那么j的范围就定义为 2 * k + 1 就可以了。

    //188. 买卖股票的最佳时机 IV
    public int maxProfit(int k, int[] prices) {
        //dp[天数][股票状态]
        //股票状态: 奇数表示第 k 次交易持有/买入, 
        //偶数表示第 k 次交易不持有/卖出, 0 表示没有操作
        int[][] dp = new int[prices.length][2 * k + 1];
}

2.确定递推公式

达到dp[i][1]状态，有两个具体操作：

操作一：第i天买入股票了，那么dp[i][1] = dp[i-1][0] - prices[i]
操作二：第i天没有操作，而是沿用前一天买入的状态，即：dp[i][1] = dp[i - 1][1]

那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？

一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);

同理dp[i][2]也有两个操作：

操作一：第i天卖出股票了，那么dp[i][2] = dp[i - 1][1] + prices[i]
操作二：第i天没有操作，沿用前一天卖出股票的状态，即：dp[i][2] = dp[i - 1][2]

同理可以类比剩下的状态，代码如下：

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

3.dp数组如何初始化
第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，这个初始值应该是多少呢？
首先卖出的操作一定是收获利润，整个股票买卖最差情况也就是没有盈利即全程无操作现金为0，
从递推公式中可以看出每次是取最大值，那么既然是收获利润如果比0还小了就没有必要收获这个利润了。
所以dp[0][2] = 0;
第0天第二次买入操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？
第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后在买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0;
所以同理可以推出dp[0][j]当j为奇数的时候都初始化为 -prices[0]

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

4.确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]依靠dp[i - 1]的数值。。
5.举例推导dp数组
以输入[1,2,3,4,5]，k=2为例。

123.买卖股票的最佳时机III

最后一次卖出，一定是利润最大的，dp[prices.size() - 1][2 * k]即红色部分就是最后求解。

3.代码实现

class Solution {
    //188. 买卖股票的最佳时机 IV
    public int maxProfit(int k, int[] prices) {
         //dp[天数][股票状态]
        //股票状态: 奇数表示第 k 次交易持有/买入, 偶数表示第 k 次交易不持有/卖出, 0 表示没有操作
        int[][] dp = new int[prices.length][2 * k + 1];
        for (int j = 1; j < 2 * k; j += 2) {
            dp[0][j] = -prices[0];
        }
        for (int i = 1; i < prices.length; i++) {
            for (int j = 0; j < 2 * k - 1; j += 2) {
                dp[i][j + 1] = Math.max(dp[i - 1][j + 1], dp[i - 1][j] - prices[i]);
                dp[i][j + 2] = Math.max(dp[i - 1][j + 2], dp[i - 1][j + 1] + prices[i]);
            }
        }
        return dp[prices.length - 1][2 * k];
    }
}

714.买卖股票的最佳时机含手续费

1.题目描述

给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格；整数 fee 代表了交易股票的手续费用。
你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
返回获得利润的最大值。

2.解题思路

本题和动态规划：122.买卖股票的最佳时机II (opens new window)的区别就是这里需要多一个减去手续费的操作。

3.代码实现

class Solution {
  //714.买卖股票的最佳时机含手续费
    public int maxProfit(int[] prices, int fee) {
        //dp[i][0]:第i天持有股票所得现金
        //dp[i][1]:第i天不持有股票所得现金
        int[][] dp = new int[prices.length][2];
        dp[0][0] = -prices[0];
        dp[0][1] = 0;
        for (int i = 1; i < prices.length; i++) {
            //第i天持有股票dp[i][0]:
            //情况1：i-1天就持有股票 dp[i - 1][0]
            //情况2：i-1天不持有股票,第i天买入 dp[i - 1][1] - prices[i]（与121唯一不同的地方）
            dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
            //第i天不持有股票 dp[i][1]:
            //情况1：i-1天就不持有股票 dp[i - 1][1]
            //情况2：i-1天就持有股票,第i天卖出 dp[i - 1][0]+prices[i]
            dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i] - fee);
        }
        return dp[prices.length - 1][1];
    }
}

309.最佳买卖股票时机含冷冻期

1.题目描述

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

2.解题思路

1.确定dp数组以及下标的含义
确定dp数组以及下标的含义
状态一：买入股票状态（今天买入股票，或者是之前就买入了股票然后没有操作）
卖出股票状态，这里就有两种卖出股票状态
状态二：两天前就卖出了股票，度过了冷冻期，一直没操作，今天保持卖出股票状态
状态三：今天卖出了股票
状态四：今天为冷冻期状态，但冷冻期状态不可持续，只有一天！

dp[i][j]，第i天状态为j，所剩的最多现金为dp[i][j]。

//309. 最佳买卖股票时机含冷冻期
    public int maxProfit(int[] prices) {
        //冷冻期：卖出股票后的第二天
        int n = prices.length;
        //dp[i][j]:i表示第i天，j为[0-3]五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        //0买入状态，1保持卖出状态，2当天卖出，3冷却期
        int[][] dp = new int[n][4];
}

2.确定递推公式

达到买入股票状态（状态一）即：dp[i][0]，有两个具体操作：

操作一：前一天就是持有股票状态（状态一），dp[i][0] = dp[i - 1][0]
操作二：今天买入了，有两种情况
前一天是冷冻期（状态四），dp[i - 1][3] - prices[i]
前一天是保持卖出股票状态（状态二），dp[i - 1][1] - prices[i]

那么dp[i][0] = max(dp[i - 1][0], max(dp[i - 1][3] - prices[i], dp[i - 1][1]) - prices[i]);

达到保持卖出股票状态（状态二）即：dp[i][1]，有两个具体操作：

操作一：前一天就是状态二
操作二：前一天是冷冻期（状态四）
dp[i][1] = max(dp[i - 1][1], dp[i - 1][3]);

达到今天就卖出股票状态（状态三），即：dp[i][2] ，只有一个操作：

操作一：昨天一定是买入股票状态（状态一），今天卖出

dp[i][2] = dp[i - 1][0] + prices[i];

达到冷冻期状态（状态四），即：dp[i][3]，只有一个操作：
操作一：昨天卖出了股票（状态三）

dp[i][3] = dp[i - 1][2];

综上分析，递推代码如下：

       for (int i = 1; i < n; i++) {
            //0买入状态
            //情况1：昨天就是买入状态了，dp[i - 1][0]
            //情况2：今天买入 1）昨天是冷冻期      dp[i - 1][3] - prices[i]
            //情况2：今天买入 2）昨天是维持卖出状态 dp[i - 1][1] - prices[i]
            dp[i][0] = Math.max(dp[i - 1][0], 
                Math.max(dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]));
            //1保持卖出状态
            //情况1：昨天是冷冻期，     dp[i - 1][3]
            //情况2：昨天是维持卖出状态，dp[i - 1][1]
            dp[i][1] = Math.max(dp[i - 1][3], dp[i - 1][1]);
            //2当天卖出状态
            //情况1：昨天是买入状态，   dp[i - 1][0]
            dp[i][2] = dp[i - 1][0] + prices[i];
            //3冷冻期状态
            //情况1：昨天是当天卖出状态，dp[i - 1][2]
            dp[i][3] = dp[i - 1][2];
        }

3.dp数组如何初始化
这里主要讨论一下第0天如何初始化。
如果是持有股票状态（状态一）那么：dp[0][0] = -prices[0]，买入股票所剩现金为负数。
保持卖出股票状态（状态二），第0天没有卖出dp[0][1]初始化为0就行，
今天卖出了股票（状态三），同样dp[0][2]初始化为0，因为最少收益就是0，绝不会是负数。
同理dp[0][3]也初始为0。

4.确定遍历顺序
从递归公式上可以看出，dp[i] 依赖于 dp[i-1]，所以是从前向后遍历。
5.举例推导dp数组
以 [1,2,3,0,2] 为例，dp数组如下：

309.最佳买卖股票时机含冷冻期

最后结果是取状态二，状态三，和状态四的最大值，不少同学会把状态四忘了，状态四是冷冻期，最后一天如果是冷冻期也可能是最大值。

3.代码实现

class Solution {
    //309. 最佳买卖股票时机含冷冻期
    public int maxProfit(int[] prices) {
        //冷冻期：卖出股票后的第二天
        int n = prices.length;
        //dp[i][j]:i表示第i天，j为[0-3]五个状态，dp[i][j]表示第i天状态j所剩最大现金。
        //0买入状态，1保持卖出状态，2当天卖出，3冷却期
        int[][] dp = new int[n][4];
        dp[0][0] = -prices[0];
        for (int i = 1; i < n; i++) {
            //0买入状态
            //情况1：昨天就是买入状态了，dp[i - 1][0]
            //情况2：今天买入 1）昨天是冷冻期      dp[i - 1][3] - prices[i]
            //情况2：今天买入 2）昨天是维持卖出状态 dp[i - 1][1] - prices[i]
            dp[i][0] = Math.max(dp[i - 1][0],
             Math.max(dp[i - 1][3] - prices[i], dp[i - 1][1] - prices[i]));
            //1保持卖出状态
            //情况1：昨天是冷冻期，     dp[i - 1][3]
            //情况2：昨天是维持卖出状态，dp[i - 1][1]
            dp[i][1] = Math.max(dp[i - 1][3], dp[i - 1][1]);
            //2当天卖出状态
            //情况1：昨天是买入状态，   dp[i - 1][0]
            dp[i][2] = dp[i - 1][0] + prices[i];
            //3冷冻期状态
            //情况1：昨天是当天卖出状态，dp[i - 1][2]
            dp[i][3] = dp[i - 1][2];
        }
        return Math.max(dp[n - 1][1], Math.max(dp[n - 1][2], dp[n - 1][3]));
    }
}