动态规划-股票问题（买卖股票的最佳时机、II、III、IV、含冷冻期、含手续费）

文章目录
1. 买卖股票的最佳时机
思路：
代码：
2. 买卖股票的最佳时机 II
思路：
代码：
3. 买卖股票的最佳时机 III
思路：
代码：
4. 买卖股票的最佳时机 IV
思路：
代码：
5. 最佳买卖股票时间含冷冻期
思路：
代码：
6. 买卖股票的最佳时机含手续费
思路：
代码：
1. 买卖股票的最佳时机
题目链接：121. 买卖股票的最佳时机 - 力扣（LeetCode）

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

你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

示例 1：

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

示例 2：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 104
思路：
下面进行动归五部曲分析：

状态定义：

dp[i] [0] 表示第 i 天持有股票的最大利润，这里说最大利润不如说是最多现金，刚开始现金是 0 ，第 i 天买入股票后现金就是 -prices[i]，这是一个负数。
dp[i] [1] 表示第 i 天不持有股票的最大利润，不持有股票时最多现金。
状态转移：、

如果第 i 天持有股票也就是 dp[i] [0], 那么可以由两个状态推出来

第 i-1 天如果也持有股票，那就保持现状，第 i 天和第 i-1 天持有股票时的最大现金是一样的：dp[i-1] [0]

第 i 天买入股票，那么现在持有股票时的最多现金就是：-prices[i]

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

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

第 i-1 天也没有持有股票，那就保持现状，第 i 天和第 i-1 天不持有股票时的最大现金是一样的：dp[i-1] [1]

第 i 太难卖出股票，那么现在持有股票时的最多现金就是：prices[i] + dp[i-1] [0]

dp[i] [1] = max(dp[i-1] [1].dp[i-1] [0]+prices[i])

初始化：由状态转移方程可以分析出，dp[0] [0] 和 dp[0] [1] 都要初始化

dp[0] [0] 表示第 0 天持有股票，那肯定是今天买入的，因为没有前一天，

dp[0] [0] = -prices[0]

dp[0] [1] 表示第 0 天不持有股票，不持有股票那么现金就是0,dp[0] [1] = 1

遍历顺序：从前到后，因为 dp[i] 都是由 dp[i-1] 推导出的

返回值：dp[prices.length-1] [1]

代码：
/**
1. 状态定义：dp[i][0] 表示第 i 天持有股票的最大利润
dp[i][1] 表示第 i 天不持有股票的最大利润
2. 状态转移：dp[i][0] = max(dp[i-1][0],-prices[i])
dp[i][1] = max(dp[i-1][1].dp[i-1][0]+prices[i])
3. 初始化：dp[0][0] = -prices[0]
dp[0][1] = 0;
4. 遍历顺序：从小到大
5. 返回值：dp[prices.length-1][1]
*/
public int maxProfit(int[] prices) {
int n = prices.length;
int[][] dp = new int[n][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i-1][0],-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);
}
return dp[n-1][1];
}

2. 买卖股票的最佳时机 II
题目链接：122. 买卖股票的最佳时机 II - 力扣（LeetCode）

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。

在每一天，你可以决定是否购买和/或出售股票。你在任何时候最多只能持有一股股票。你也可以先购买，然后在同一天出售。

返回你能获得的最大利润。

示例 1：

输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。
总利润为 4 + 3 = 7 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
总利润为 4 。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104
思路：
这道题和上到题大体上是一样的，唯一的区别就是，上一题中的股票只能买卖一次，本道题中的股票可以买卖多次了，但还是同时只能持有一支股票

基本上动态五部曲是一样的

状态定义：dp[i] [0] 表示第 i 天持有股票所得最多现金

dp[i] [1] 表示第 i 天不持有股票所得最多现金

状态转移：只有这个是和上一题是有区别的

如果第 i 天持有股票也就是 dp[i] [0]，那么可以由两个状态推导出来。
第 i - 1 天就已经持有股票了，那就保持现状，昨天和今天持有股票所得的最大现金是一样的 dp[i-1] [0]
第 i 天买入股票，所得最多现金就是昨天不持有股票时的最大现金减去今天买入股票时的价格 dp[i-1] [1] - prices[i] (这个就是两道题中的不同之处，上一题中因为股票全程只能买卖一次，所以如果买入股票，那么第 i 天持有股票 dp[i] [0] 一定是 -prices[i]，而本道题因为一只股票可以买卖多次，所以当第 i 天买入股票时，所持有的现金可能有之前买卖过的利润，所以第 i 天买入股票 dp[i] [0] ，就是昨天不持有股票所得现金减去今天的股票价格 dp[i-1] [1] - prices[i])
如果第 i 天不持有股票 dp[i] [1]，可以由这两个状态推导出来

第 i - 1 天就不持有股票，那么今天还是保持现状，此时最多现金就是昨天不持有股票时的现金 dp[i-1] [1]
第 i 天卖出股票，那么做多现金就是按照今天股票价格卖出后所得现金加上昨天持有股票时的现金 dp[i-1] [0] + prices[i]
初始化：由状态转移方程可以分析出，dp[0] [0] 和 dp[0] [1] 都要初始化

dp[0] [0] 表示第 0 天持有股票，那肯定是今天买入的，因为没有前一天，

dp[0] [0] = -prices[0]

dp[0] [1] 表示第 0 天不持有股票，不持有股票那么现金就是0,dp[0] [1] =1

遍历顺序：从前到后，因为 dp[i] 都是由 dp[i-1] 推导出的

返回值：dp[prices.length-1] [1]

代码：
/**
1. 状态定义：
2. 状态转移：
3. 初始化：
4. 遍历顺序：
5. 返回值：
*/
public int maxProfit(int[] prices) {
int n = prices.length;
int[][] dp = new int[n][2];
dp[0][0] = -prices[0];
dp[0][1] = 0;
for(int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]);

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

3. 买卖股票的最佳时机 III
题目链接：123. 买卖股票的最佳时机 III - 力扣（LeetCode）

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

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

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

示例 1:

输入：prices = [3,3,5,0,0,3,1,4]
输出：6
解释：在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天（股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。

示例 2：

输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。
因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

示例 3：

输入：prices = [7,6,4,3,1]
输出：0
解释：在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4：

输入：prices = [1]
输出：0

提示：

1 <= prices.length <= 105
0 <= prices[i] <= 105
思路：
本道题相比于前两道题，核心又变成了股票最多买卖两次，这说明可以买卖一次，也可以买卖两次，也可以不买卖。

下面继续用动态五部曲来分析一下

状态定义：一天可以有五个状态

没有操作 dp[i] [0]
第一次持有股票 dp[i] [1]
第一次不持有股票 dp[i] [2]
第二次持有股票 dp[i] [3]
第二次不持有股票 dp[i] [4]
dp[i] [j] 中 i 表示第 i 天，j 表示 0-4 五个状态，dp[i] [j] 表示第 i 天状态 j 所剩最大现金。这里需要注意 dp[i] [1] 表示的是第 i 天，买入股票的状态，并不是说一定要第 i 天买入股票，也可以是前几天买的，今天继续持有的。

状态转移：

dp[i] [1] 这种结果，有两种状态：

第 i 天第一次买入股票了，那么 dp[i] [1] = dp[i-1] [0] - prices[i]
第 i 天没有操作，而是继续保持前一天买入的状态，dp[i] [1] = dp[i-1] [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]
取这两种状态中最大的 max(dp[i-1] [1] + prices[i],dp[i-1] [2])

同样推导 dp[i] [3],dp[i] [4]

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

（第 i 天第二次买入股票；第 i 天没有操作，而是继续保持前一天第二次买入的状态）

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

（第 i 天卖出股票；第 i 天没有操作，而是继续保持前一天第二次卖出的状态）

初始化；可以根据状态定义来分析，怎么进行初始化

dp[0] [0] 表示第 0 天没有操作，那肯定是初始化为 dp[0] [0] = 0
dp[0] [1] 表示第 0 天第一次买入股票，dp[0] [1] = -prices[0]
dp[0] [2] 表示第 0 天第一次卖出股票，可以理解为我今天买入，今天又想卖出，所以 dp[0] [2] = 0
dp[0] [3] 表示第 0 天第二次买入股票，至于为什么是第二次，可以这样理解，我今天买入又卖出了，我现在又想买入了，所以 dp[0] [3] = -preices[0]
还是这样的理解，第二次卖出初始化为 dp[0] [4] = 0;
遍历顺序：从前向后，因为 dp[i] 依靠 dp[i-1]
返回值：dp[prices.length -1] [4]
代码：
/**
1. 状态定义：
2. 状态转移：
3. 初始化：
4. 遍历顺序：
5. 返回值：
*/
public int maxProfit(int[] prices) {
int n = prices.length;
int[][] dp = new int[n][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 < n; i++) {
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]-prices[i]);
dp[i][2] = Math.max(dp[i-1][2],dp[i-1][1]+prices[i]);
dp[i][3] = Math.max(dp[i-1][3],dp[i-1][2]-prices[i]);
dp[i][4] = Math.max(dp[i-1][4],dp[i-1][3]+prices[i]);
}
return dp[n-1][4];
}

4. 买卖股票的最佳时机 IV
题目链接：188. 买卖股票的最佳时机 IV - 力扣（LeetCode）

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

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

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

示例 1：

输入：k = 2, prices = [2,4,1]
输出：2
解释：在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。

示例 2：

输入：k = 2, prices = [3,2,6,5,0,3]
输出：7
解释：在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。

提示：

0 <= k <= 100
0 <= prices.length <= 1000
0 <= prices[i] <= 1000
思路：
在上一题买卖股票的最佳时机 III 中，最多可以买卖两次股票，而在本题中，这个条件升级了，可以买卖 k 次。

还是进行动归五部曲分析

状态定义：

在上道题中，定义的是一个二维数组， i 表示每一天， j 表示第几次买入卖出，不过上道题的dp 数组是 dp[i] [4]，因为只能最多有两次买入卖出的机会。还是和上道题一样，使用二维数组 dp[i] [j] ：第 i 天的状态为 j ，所剩的最大现金是 dp[i] [j]

j 的状态表示为

0 表示不操作
1 表示第一次买入
2 表示第一次卖出
3 表示第二次买入
4 表示第二次卖出
…
也就是除了 0 外，奇数就是买入，偶数就是卖出。

题目要求是最多有 k 次交易，所以 j 的范围就为 2*k+1

状态转移：

当 dp[i] [奇数] 状态时，可以有两个操作：

第 i 天买入股票，dp[i] [j] - prices[i]

第 i 天没有操作，继续沿用前一天买入的状态 dp[i-1] [j+1]

所以取这两种情况中最大的 p[i] [j+1] = max( dp[i-1] [j+1], dp[i] [j] - prices[i] )

当 dp[i] [偶数] 状态时，可以有两个操作：

第 i 天卖出股票，dp[i-1] [j-1] + prices[i]
第 i 天没有操作，继续保持前一天买入的状态 dp[i-1] [j+2]
初始化：dp[0] [j] = -prices[0]; j+=2

遍历顺序：遍历天数从小到大，遍历第几次买入 j 从小到大

返回值：dp[preices.length-1] [2*k]

代码：
/**
1. 状态定义：第 i 天时，持有的最大利润为 dp[i][2k]
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][j] = -prices[0]; j+=2
4. 遍历顺序：遍历天数从小到大，遍历第几次买入 j 从小到大
5. 返回值：dp[preices.length-1][2*k]
*/
public int maxProfit(int k, int[] prices) {
int n = prices.length;
int[][] dp = new int[n][2*k+1];
// 初始化
for(int j = 1; j < 2*k; j += 2) {
dp[0][j] = -prices[0];
}
// 遍历状态转移方程
for(int i = 1; i < n; 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[n-1][2*k];
}

5. 最佳买卖股票时间含冷冻期
题目链接：309. 最佳买卖股票时机含冷冻期 - 力扣（LeetCode）

给定一个整数数组prices，其中第 prices[i] 表示第 i 天的股票价格。

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

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

示例 1:

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

示例 2:

输入: prices = [1]
输出: 0

提示：

1 <= prices.length <= 5000
0 <= prices[i] <= 1000
思路：
在买卖股票的最佳时机 II 中，股票是可以买卖多次，但还是同时只能持有一支股票，本题相较于 II 多个一个冷冻期，就是在卖出股票后，下一天为冷冻期。

之前做买卖股票的最佳时机 I、II、III、IV，中都是把【今天卖出股票】这个状态放在了【不持有股票的状态】，本题就是因为多了一个冷冻期，冷冻期的前一天之内是【今天卖出股票】这个状态，所以本道题中的状态必须细分。

下面进行动归五部曲分析

状态定义：dp[i] [j] 表示：第 i 天状态为 j ，所剩最多现金为 dp[i] [j]

因为本道题中多了一个冷冻期，所以状态是比较复杂的。具体有这四种情况：

状态一：持有股票状态（今天买入的；之前买入的然后现在继续持有）

不持有股票状态，又可以分为

状态二保持卖出股票状态（两天前就已经卖出了股票，并且把冷冻期刚刚度过了；很早之前就把股票卖了，一直没操作，还是保持着卖出股票的状态）

状态三：今天刚卖出股票

状态四：今天为冷冻期

状态转移：

状态一：持有股票状态

之前买入的然后现在继续持有：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], dp[i-1] [3] - prices[i], dp[i-1] [1] - prices[i])

状态二：保持卖出股票状态

两天前就已经卖出了股票，并且把冷冻期刚刚度过了(前一天就是冷冻期)

dp[i-1] [3]

很早之前就把股票卖了，一直没操作，还是保持着卖出股票的状态

dp[i-1] [1]

所以 dp[i] [1] = max(dp[i-1] [3], dp[i-1] [1])

状态三：今天刚卖出股票那昨天一定是持有状态，今天卖出 dp[i] [2] = dp[i-1] [0] + prices[i]

**状态四：今天为冷冻期 **，那肯定是昨天刚卖出股票了 dp[i] [3] = dp[i-1] [2]

初始化：这个只初始化个 dp[0] [0] ，因为状态一就是持有股票的状态，那一定是当天买入股票的 dp[0] [0] = -prices[i]

至于其他状态都是 0，因为比如说第 0 天，你把状态二保持卖出股票的状态初始化为其他数值，那说明手中剩下的现金数量是不对的，同理状态三和状态四都要为 0

遍历顺序：从前到后，这个可以由状态转移方程可以看出来

返回值：max(dp[n - 1] [3], max(dp[n - 1] [1], dp[n - 1] [2])

代码：
/**
1. 状态定义：dp[n][4]
2. 状态转移：
3. 初始化；
4. 遍历顺序：
5. 返回值：
*/
public int maxProfit(int[] prices) {
int n = prices.length;
int[][] dp = new int[n][4];
// 初始化
dp[0][0] = -prices[0];
// 遍历状态转移方程
for(int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i-1][0],Math.max(dp[i-1][3]-prices[i],dp[i-1][1]-prices[i]));
dp[i][1] = Math.max(dp[i-1][3],dp[i-1][1]);
dp[i][2] = dp[i-1][0] + prices[i];
dp[i][3] = dp[i-1][2];
}
return Math.max(dp[n-1][3],Math.max(dp[n-1][1],dp[n-1][2]));
}

6. 买卖股票的最佳时机含手续费
题目链接：714. 买卖股票的最佳时机含手续费 - 力扣（LeetCode）

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

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

返回获得利润的最大值。

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

示例 1：

输入：prices = [1, 3, 2, 8, 4, 9], fee = 2
输出：8
解释：能够达到的最大利润:
在此处买入 prices[0] = 1
在此处卖出 prices[3] = 8
在此处买入 prices[4] = 4
在此处卖出 prices[5] = 9
总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8

示例 2：

输入：prices = [1,3,7,5,10,3], fee = 3
输出：6

提示：

1 <= prices.length <= 5 * 104
1 <= prices[i] < 5 * 104
0 <= fee < 5 * 104
思路：
本道题和【买卖股票的最佳时机 II】几乎一样，唯一的区别就是多了一个每次卖出股票后，都要受手续费

所以动态五部曲中，唯一的区别就是状态转移方程

当 dp[i] [1] 也就是股票没有持有时（前一天也是没有持有的，今天不操作，保持前一天的状态；昨天持有股票，但今天卖出【这里要注意卖出股票后要收手续费】）

代码：
/**
1. 状态定义：第 i 天，股票的状态为 0 时，表示持有 dp[i][0]
股票的状态为 1 时，表示不持有 dp[i][1]
2. 状态转移：
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
相比于【买卖股票的最佳时机 II】，唯一的区别就是每次卖出后，都要收一个手续费
3. 初始化：dp[0][0] = -prices[0] // 初始化第一次买入时
4. 遍历顺序：从小到大
5. 返回值：dp[n-1][1]
*/
public int maxProfit(int[] prices, int fee) {
int n = prices.length;
int[][] dp = new int[n][2];
dp[0][0] = -prices[0];
for(int i = 1; i < n; i++) {
dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]-prices[i]);
dp[i][1] = Math.max(dp[i-1][1],dp[i-1][0]+prices[i]-fee);
}
return dp[n-1][1];
}
————————————————
版权声明：本文为CSDN博主「快到锅里来呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_58761900/article/details/129914794