股票交易问题全拿下，一扫光

上来直接最难的，后面都是毛毛雨

问题一：买卖股票的最佳时机IV（leetcode188）

问题二：最大可交易次数不限（leetcode122）

问题三：最大交易次数为1（leetcode121）

问题四：最大交易次数为2（leetcode123）

问题五：买卖股票最佳时间含手续费（leetcode714）

问题六：最佳股票买卖时机含冷冻期（leetcode309）

问题一：买卖股票的最佳时机IV（leetcode188）

问题描述：

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

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

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

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

大体思路：

二维数组dp0[i][j]表示在第i天，最大可交易次数为j时不持有股票的最大收益；

同理dp1[i][j]表示在第天，最大可交易次数为j时持有股票的最大收益。i从0到最大天数，j从0到k。

dp0[i][j] = max(dp0[i - 1][j], dp1[i - 1][j] + prices[i])

dp1[i][j] = max(dp1[i - 1][j], dp0[i - 1][j - 1] - prices[i])

第一个式子：当天没有股票有两种可能，要么前一天就没持有股票；要么为前一天持有股票，当天卖了。

第二个式子：当天持有股票有两种可能，要么前一天就持有股票，或者前一天没持有股票，当天买入了。

注：这里需要注意的是第二个式子中，第二种情况下的前一天的最大可交易次数为j-1而不为j，这是由于买入的次数要小于最大买入次数，假设为dp0[i - 1][j] 他可能在i-1天之前已经进行过j次交易了，在第i天坑定不能再买入了。

传递函数有了，下面描述其的初值。

我们从传递函数发现，当前值总是与其正上方的值和左上角的值有关，因此只要对dp0和dp1的第一列第一行初始化即可。

dp0的第一列和第一行均为0，首先第一列j=0,由于最大可交易次数为0，那坑定不能买了为0，第一行i= 0,由于在第1天，不持有股票只有一种可能就是没有买所以为0。

dp1的第一列，j= 0最大可交易次数为0，但是还要持有，这是不可能实现的，因此为非法状态统统设为负无穷；第一行（除第一个元素）i = 0,可交易次数大于0了，在第1天想持有股票，只能买第一天的，因此统统设为 -1 * prices[0]。

实现代码如下：

class Solution {public int maxProfit(int k, int[] prices) {if(k == 0 || prices.length <= 1){return 0;}if(k > prices.length / 2){return maxProfit(prices);}int[][] dp0 = new int[prices.length][k + 1];int[][] dp1 = new int[prices.length][k + 1];/* dp0[i][0] 和 dp0[0][j] 均为0*/for(int i = 0; i < prices.length; i++){dp1[i][0] = Integer.MIN_VALUE;}for(int j = 1; j < k + 1; j++){dp1[0][j] = -1 * prices[0];}for(int i = 1; i < prices.length; i++){for(int j = 1; j < k + 1; j++){dp0[i][j] = Math.max(dp0[i - 1][j], dp1[i - 1][j] + prices[i]);dp1[i][j] = Math.max(dp1[i - 1][j], dp0[i - 1][j - 1] - prices[i]);}}return dp0[prices.length - 1][k];}public int maxProfit(int[] prices) {if(prices.length <= 1){return 0;}int[] dp0 = new int[prices.length];int[] dp1 = new int[prices.length];dp1[0] = -1 * prices[0];for(int i = 1; i < dp0.length; i++){dp0[i] = Math.max(dp0[i - 1], dp1[i - 1] + prices[i]);dp1[i] = Math.max(dp1[i - 1], dp0[i - 1] - prices[i]);}return dp0[dp0.length - 1];}
}

由于k可能很大，当k > n / 2时问题就会转化为不用考虑最大交易次数的情况，可以认为最大交易次数为无穷。后面的代码下一节将会分析。

问题二：最大可交易次数不限（leetcode122）

该问题是问题一中k = 无穷的特例，此时 k = k - 1,因此转移函数变为

dp0[i] = max(dp0[i - 1], dp1[i - 1] + prices[i])

dp1[i] = max(dp1[i - 1], dp0[i - 1] - prices[i])

问题由二维dp转化为一维dp

初值为：d0[0] = 0,没买肯定是0啊， d1[0] = -prices[0]，买了肯定是- prices[0]。

实现代码如下：

    public int maxProfit(int[] prices) {if(prices.length <= 1){return 0;}int[] dp0 = new int[prices.length];int[] dp1 = new int[prices.length];dp1[0] = -1 * prices[0];for(int i = 1; i < dp0.length; i++){dp0[i] = Math.max(dp0[i - 1], dp1[i - 1] + prices[i]);dp1[i] = Math.max(dp1[i - 1], dp0[i - 1] - prices[i]);}return dp0[dp0.length - 1];}

问题三：最大交易次数为1（leetcode121）

dp0[i][j] = max(dp0[i - 1][j], dp1[i - 1][j] + prices[i])

dp1[i][j] = max(dp1[i - 1][j], dp0[i - 1][j - 1] - prices[i])

将上式中的j换成1，得到如下：

dp0[i][1] = max(dp0[i - 1][1], dp1[i - 1][1] + prices[i])

dp1[i][1] = max(dp1[i - 1][1], dp0[i - 1][0] - prices[i])

由于dp0[i - 1][0] = 0,所以最终化简后的转移方程为：

dp0[i]= max(dp0[i - 1], dp1[i - 1]+ prices[i])

dp1[i]= max(dp1[i - 1], 0 - prices[i])

初值：dp0[0] = 0, dp1[0] = -prices[0]

该结果也可以使用自然语言理解，当天不持有的有两种情况，或者前一天就不持有，或者前一天持有当天卖出去了；当天持有的两种情况为：前一天就持有，或者前一天不会持有，当天买了。由于只能买一次，前一天不持有说明之前也没进行过交易，因此前一天不持有的最大收益为0.

实现代码如下：

    public int maxProfit(int[] prices) {if(prices.length <= 1){return 0;}int[] dp0 = new int[prices.length];//  dp0[i] i天不持有股票的最大利润int[] dp1 = new int[prices.length]; // 持有股票的最大利润 dp0[0] = 0;dp1[0] = -1 * prices[0];for(int i = 1; i < prices.length; i++){dp0[i] = Math.max(dp0[i - 1], dp1[i - 1] + prices[i]);dp1[i] = Math.max(dp1[i - 1], 0 - prices[i]);}return dp0[dp0.length - 1];}

当然由于只交易一次，因此还可以很多其他办法解决，比如可以使用贪心的策略，找到当前点之前最小的元素，即在前面那个位置买，在当前点卖。由于本文主要将dp,这里就不多加赘述了。

问题四：最大交易次数为2（leetcode123）

这问题没啥说的，就令k=2咯，直接搞。

代码如下：

    public int maxProfit(int[] prices) {if(prices.length <= 1){return 0;}int K = 2;int[][] dp0 = new int[prices.length][K + 1];int[][] dp1 = new int[prices.length][K + 1]; // dp0[0][k] 和 dp0[i][0] 均为0for(int i = 0; i < prices.length; i++){ // 第一列 最大允许交易次数为0 还要持有 定为非法dp1[i][0] = Integer.MIN_VALUE;}for(int k = 1; k <= K; k++){ //第一行dp1[0][k] = -1 * prices[0];}for(int i = 1; i < prices.length; i++){for(int k = 1; k <= K; k++){dp0[i][k] = Math.max(dp0[i - 1][k], dp1[i - 1][k] + prices[i]);dp1[i][k] = Math.max(dp1[i - 1][k], dp0[i - 1][k - 1] - prices[i]);}}return dp0[prices.length - 1][K];}

问题五：买卖股票最佳时间含手续费（leetcode714）

问题描述：

给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格；非负整数 fee 代表了交易股票的手续费用。

你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

返回获得利润的最大值。

注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

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

大体思路：

直接在k=无穷上改就行，由于每笔交易都含手续费，因此在卖的时候加上手续费就行，转移方程如下:

dp0[i] = max(dp0[i - 1], dp1[i - 1] + prices[i] - fee)

dp1[i] = max(dp1[i - 1], dp0[i - 1] - prices[i])

初值 dp0[0] = 0, dp1[0] = - prices[0]

代码如下：

    public int maxProfit(int[] prices, int fee) {if(prices.length <= 1){return 0;}int[] dp0 = new int[prices.length];int[] dp1 = new int[prices.length];dp1[0] = -1 * prices[0];for(int i = 1; i < prices.length; i++){dp0[i] = Math.max(dp0[i - 1], dp1[i - 1] + prices[i] - fee);dp1[i] = Math.max(dp1[i - 1], dp0[i - 1] - prices[i]);}return dp0[dp0.length - 1];}

问题六：最佳股票买卖时机含冷冻期（leetcode309）

问题描述：

给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格。

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
示例:

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

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

大体思路：

由于当天卖出股票后第二天不能直接买入，也就是说只有前天没持有，昨天没持有，今天才可以进行买入。传递函数如下：

dp0[i] = max(dp0[i - 1], dp1[i - 1] + prices[i])

dp1[i] = max(dp1[i - 1], dp0[i - 2] - prices[i])

由于前天没有持有，昨天也没有持有，今天买入之前的收益是等于前天的收益的。因此为dp0[i - 2] - prices[i]

由于用到i- 2，初值除了赋i= 0，还应对 i = 1赋值。

dp0[0] = 0;

dp1[0] = 0 - prices[0];

dp0[1] = Math.max(dp0[0], dp1[0] + prices[1]);

dp1[1] = Math.max(dp1[0], dp0[0] - prices[1]);// 由于-1时坑定没卖出，因此为dp0[0] - prices[1]。

实现代码如下：

    public int maxProfit(int[] prices) {// return dfs(prices, 0, 0, 0, 0);if(prices.length <= 1){return 0;}int[] dp0 = new int[prices.length]; //dp0[i] 为i天不持有股票的最大收益int[] dp1 = new int[prices.length]; //dp0[0] = 0;dp1[0] = 0 - prices[0];dp0[1] = Math.max(dp0[0], dp1[0] + prices[1]);dp1[1] = Math.max(dp1[0], dp0[0] - prices[1]);for(int i = 2; i < prices.length; i++){dp0[i] = Math.max(dp0[i - 1], dp1[i - 1] + prices[i]);dp1[i] = Math.max(dp1[i - 1], dp0[i - 2] - prices[i]);}return dp0[prices.length - 1];}