122.买卖股票的最佳时机II
123.买卖股票的最佳时机III
188.买卖股票的最佳时机IV
714.买卖股票的最佳时机含手续费
总结
121. 买卖股票的最佳时机
全程只能买卖一次
贪心算法
这个算法的写法也非常有意思！左边小右边大，所以从左向右进行搜索！
用当前的价格减去左边的最小值
class Solution { public: int maxProfit(vector<int>& prices) { int low = INT_MAX; int result = 0; for (int i = 0; i < prices.size(); i++) { low = min(low, prices[i]); // 取最左最小价格 result = max(result, prices[i] - low); // 直接取最大区间利润 } return result; } };
动态规划
比昨天有效果，自己写出了定义，但是dp方程的书写还要提高能力
动规五部曲分析如下：
- 确定dp数组（dp table）以及下标的含义
dp[i][0] 表示第i天持有股票所得最多现金 ，这里可能有同学疑惑，本题中只能买卖一次，持有股票之后哪还有现金呢？
其实一开始现金是0，那么加入第i天买入股票现金就是 -prices[i]， 这是一个负数。
dp[i][1] 表示第i天不持有股票所得最多现金
注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态
很多同学把“持有”和“买入”没区分清楚。
在下面递推公式分析中，我会进一步讲解。
- 确定递推公式
如果第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]);
这样递推公式我们就分析完了
- dp数组如何初始化
由递推公式 dp[i][0] = max(dp[i - 1][0], -prices[i]); 和 dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);可以看出
其基础都是要从dp[0][0]和dp[0][1]推导出来。
那么dp[0][0]表示第0天持有股票，此时的持有股票就一定是买入股票了，因为不可能有前一天推出来，所以dp[0][0] -= prices[0];
dp[0][1]表示第0天不持有股票，不持有股票那么现金就是0，所以dp[0][1] = 0;
- 确定遍历顺序
从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。
- 举例推导dp数组
class Solution: def maxProfit(self, prices: List[int]) -> int: n = len(prices) #pd[i][0] = have the stock #pd[i][1] = haven't the stock pd = [[0 for _ in range(2)] for _ in range(n+1)] pd[0][0] = -prices[0] pd[0][1] = 0 for i in range(1, n): pd[i][0] = max(pd[i-1][0], -prices[i]) pd[i][1] = max(pd[i-1][1], pd[i-1][0]+prices[i]) return max(pd[n-1][0], pd[n-1][1])
122.买卖股票的最佳时机II
前段时间用的是贪心算法
注意这里和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]。
再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来
- 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
- 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]
class Solution: def maxProfit(self, prices: List[int]) -> int: # ans = 0 # for i in range(1, len(prices)): # ans += max(0, prices[i]-prices[i-1]) # return ans n = len(prices) # dp[0][0] 买 # dp[0][1] 卖 dp = [[0 for _ in range(2)] for _ in range(n+1)] dp[0][0] = -prices[0] dp[0][1] = 0 for i in range(1, n): dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i]) dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i]) return dp[n-1][1]
123.买卖股票的最佳时机III
这道题目相对 121.买卖股票的最佳时机 (opens new window)和 122.买卖股票的最佳时机II (opens new window)难了不少。
关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
接来下我用动态规划五部曲详细分析一下：
- 确定dp数组以及下标的含义
一天一共就有五个状态，
- 没有操作 （其实我们也可以不设置这个状态）
- 第一次持有股票
- 第一次不持有股票
- 第二次持有股票
- 第二次不持有股票
dp[i][j]中 i表示第i天，j为 [0 - 4] 五个状态，dp[i][j]表示第i天状态j所剩最大现金。
需要注意：dp[i][1]，表示的是第i天，买入股票的状态，并不是说一定要第i天买入股票，这是很多同学容易陷入的误区。
例如 dp[i][1] ，并不是说 第i天一定买入股票，有可能 第 i-1天 就买入了，那么 dp[i][1] 延续买入股票的这个状态。
- 确定递推公式
达到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]);
- dp数组如何初始化
第0天没有操作，这个最容易想到，就是0，即：dp[0][0] = 0;
第0天做第一次买入的操作，dp[0][1] = -prices[0];
第0天做第一次卖出的操作，这个初始值应该是多少呢？
此时还没有买入，怎么就卖出呢？ 其实大家可以理解当天买入，当天卖出，所以dp[0][2] = 0;
第0天第二次买入操作，初始值应该是多少呢？应该不少同学疑惑，第一次还没买入呢，怎么初始化第二次买入呢？
第二次买入依赖于第一次卖出的状态，其实相当于第0天第一次买入了，第一次卖出了，然后再买入一次（第二次买入），那么现在手头上没有现金，只要买入，现金就做相应的减少。
所以第二次买入操作，初始化为：dp[0][3] = -prices[0];
同理第二次卖出初始化dp[0][4] = 0;
- 确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。
- 举例推导dp数组
class Solution: def maxProfit(self, prices: List[int]) -> int: if len(prices) == 0: return 0 dp = [[0] * 5 for _ in range(len(prices))] dp[0][1] = -prices[0] dp[0][3] = -prices[0] for i in range(1, len(prices)): dp[i][0] = dp[i-1][0] dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i]) dp[i][2] = max(dp[i-1][2], dp[i-1][1] + prices[i]) 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]) return dp[-1][4]
188.买卖股票的最佳时机IV
可以交易k次 上一题的延伸
class Solution: def maxProfit(self, k: int, prices: List[int]) -> int: if len(prices) == 0: return 0 dp = [[0] * (2*k+1) for _ in range(len(prices))] for j in range(1, 2*k, 2): dp[0][j] = -prices[0] for i in range(1, len(prices)): for j in range(0, 2*k-1, 2): dp[i][j+1] = max(dp[i-1][j+1], dp[i-1][j] - prices[i]) dp[i][j+2] = max(dp[i-1][j+2], dp[i-1][j+1] + prices[i]) return dp[-1][2*k]
309.最佳买卖股票时机含冷冻期
和122题差不多
但是注意到不能卖过以后立刻购买，所以
dp[i][0] = max(dp[i-1][0], dp[i-2][1]-prices[i])
的公式改一下，以及初始化的地方改一改
- 时间复杂度：O(n)
- 空间复杂度：O(n)
class Solution: def maxProfit(self, prices: List[int]) -> int: n = len(prices) if n <= 1: return 0 if n == 2: return max(0, (prices[1]-prices[0])) dp = [[0 for _ in range(2)] for _ in range(n)] dp[0][0] = -prices[0] dp[0][1] = 0 dp[1][0] = max(dp[0][0], -prices[1]) dp[1][1] = max(dp[0][1], dp[0][0]+prices[1]) for i in range(2, n): dp[i][0] = max(dp[i-1][0], dp[i-2][1]-prices[i]) dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i]) return dp[n-1][1]
714.买卖股票的最佳时机含手续费
没啥好说的 就是122差不多的题目 卖出的时候需要多减fee
- 时间复杂度：O(n)
- 空间复杂度：O(n)
class Solution: def maxProfit(self, prices: List[int], fee: int) -> int: n = len(prices) dp = [[0 for _ in range(2)]for _ in range(n)] dp[0][0] = -prices[0] dp[0][1] = 0 for i in range(1, n): dp[i][0] = max(dp[i-1][0], dp[i-1][1]-prices[i]) dp[i][1] = max(dp[i-1][1], dp[i-1][0]+prices[i]-fee) return dp[n-1][1]
Leetcode股票问题总结篇!
