121. 买卖股票的最佳时机
力扣题目链接(opens new window)
给定一个数组 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。
暴力
这道题目最直观的想法，就是暴力，找最优间距了。
class Solution {public int maxProfit(int[] prices) {int result = 0;for (int i = 0; i < prices.length; i++) {for (int j = i + 1; j < prices.length; j++){result = Math.max(result, prices[j] - prices[i]);}}return result;}
};
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
当然该方法超时了。
贪心
因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。
Java 代码如下：
class Solution {public int maxProfit(int[] prices) {int low = Integer.MAX_VALUE;int result = 0;for (int i = 0; i < prices.length; i++) {low = Math.min(low, prices[i]); // 取最左最小价格result = Math.max(result, prices[i] - low); // 直接取最大区间利润}return result;}
};
- 时间复杂度：O(n)
- 空间复杂度：O(1)
动态规划
动规五部曲分析如下：
-
确定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] = Math.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] = Math.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数组
以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：
dp[5][1]就是最终结果。
为什么不是dp[5][0]呢？
因为本题中不持有股票状态所得金钱一定比持有股票状态得到的多！
以上分析完毕，Java 代码如下：
class Solution {public int maxProfit(int[] prices) {if (prices == null || prices.length == 0) return 0;int length = prices.length;// dp[i][0]代表第i天持有股票的最大收益// dp[i][1]代表第i天不持有股票的最大收益int[][] dp = new int[length][2];dp[0][0] = -prices[0];dp[0][1] = 0;for (int i = 1; i < length; i++) {dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);dp[i][1] = Math.max(dp[i - 1][0] + prices[i], dp[i - 1][1]);}return dp[length - 1][1];}
}- 时间复杂度：O(n)
- 空间复杂度：O(n)
从递推公式可以看出，dp[i] 只是依赖于 dp[i - 1] 的状态。
dp[i][0] = Math.max(dp[i - 1][0], -prices[i]);
dp[i][1] = Math.max(dp[i - 1][1], prices[i] + dp[i - 1][0]);
那么我们只需要记录 当前天的dp状态和前一天的dp状态就可以了，可以使用滚动数组来节省空间，代码如下：
class Solution {public int maxProfit(int[] prices) {int len = prices.length;int dp[][] = new int[2][2];dp[0][0] = - prices[0];dp[0][1] = 0;for (int i = 1; i < len; i++){// 用奇偶来滑动数组dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], - prices[i]);dp[i % 2][1] = Math.max(dp[(i - 1) % 2][1], prices[i] + dp[(i - 1) % 2][0]);}return dp[(len - 1) % 2][1];}
}- 时间复杂度：O(n)
- 空间复杂度：O(1)
这里能写出版本一就可以了，版本二虽然原理都一样，但是想直接写出版本二还是有点麻烦，容易自己给自己找bug。
所以建议是先写出版本一，然后在版本一的基础上优化成版本二，而不是直接就写出版本二。
还有一维数组的版本：
class Solution {public int maxProfit(int[] prices) {int[] dp = new int[2];// 记录一次交易，一次交易有买入卖出两种状态// 0代表持有，1代表卖出dp[0] = -prices[0];dp[1] = 0;// 可以参考斐波那契问题的优化方式// 我们从 i=1 开始遍历数组，一共有 prices.length 天，// 所以是 i<=prices.lengthfor (int i = 1; i <= prices.length; i++) {// 前一天持有；或当天买入dp[0] = Math.max(dp[0], -prices[i - 1]);// 如果 dp[0] 被更新，那么 dp[1] 肯定会被更新为正数的 dp[1]// 而不是 dp[0]+prices[i-1]==0 的0，// 所以这里使用会改变的dp[0]也是可以的// 当然 dp[1] 初始值为 0 ，被更新成 0 也没影响// 前一天卖出；或当天卖出, 当天要卖出，得前一天持有才行dp[1] = Math.max(dp[1], dp[0] + prices[i - 1]);}return dp[1];}
}122.买卖股票的最佳时机II
力扣题目链接(opens new window)
给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:
输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。示例 2:
输入: [1,2,3,4,5]
输出: 4
解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。示例 3:
输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。提示：
- 1 <= prices.length <= 3 * 10 ^ 4
- 0 <= prices[i] <= 10 ^ 4
本题我们在讲解贪心专题的时候就已经讲解过了 贪心算法：买卖股票的最佳时机Ⅱ 已经讲过了，只不过没有讲解动态规划的解法，那么这次我们再好好分析一下动规的解法。
本题和上题的唯一区别是本题股票可以买卖多次了（注意只有一只股票，所以再次购买前要出售掉之前的股票）
在动规五部曲中，这个区别主要是体现在递推公式上，其他都和上题一样一样的。
所以我们重点讲一讲递推公式。
这里重申一下dp数组的含义：
- 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]
注意这里和上题唯一不同的地方，就是推导 dp[i][0]的时候，第 i 天买入股票的情况。
在上题中，因为股票全程只能买卖一次，所以如果买入股票，那么第 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]
注意这里和上题就是一样的逻辑，卖出股票收获利润（可能是负值）天经地义！
代码如下：（注意代码中的注释，标记了和121.买卖股票的最佳时机唯一不同的地方）
class Solution // 实现1：二维数组存储// 可以将每天持有与否的情况分别用 dp[i][0] 和 dp[i][1] 来进行存储// 时间复杂度：O(n)，空间复杂度：O(n)public int maxProfit(int[] prices) {int n = prices.length;int[][] dp = new int[n][2]; // 创建二维数组存储状态dp[0][1] = 0; // 初始状态dp[0][0] = -prices[0];for (int i = 1; i < n; ++i) {dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] + prices[i]); // 第 i 天，没有股票dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] - prices[i]); // 第 i 天，持有股票}return dp[n - 1][1]; // 卖出股票收益高于持有股票收益，因此取[0]}
}- 时间复杂度：O(n)
- 空间复杂度：O(n)
大家可以本题和上题的代码几乎一样，唯一的区别在：
dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
这正是因为本题的股票可以买卖多次！ 所以买入股票的时候，可能会有之前买卖的利润即：dp[i - 1][1]，所以dp[i - 1][1] - prices[i]。
想到到这一点，对这两道题理解的就比较深刻了。
这里我依然给出滚动数组的版本，Java代码如下：
class Solution {public int maxProfit(int[] prices) {int dp[][] = new int [2][2];//dp[i][0]: holding the stock//dp[i][1]: not holding the stockdp[0][0] = - prices[0];dp[0][1] = 0;for(int i = 1; i < prices.length; i++){dp[i % 2][0] = Math.max(dp[(i - 1) % 2][0], dp[(i - 1) % 2][1] - prices[i]);dp[i % 2][1] = Math.max(dp[(i - 1) % 2][1], dp[(i - 1) % 2][0] + prices[i]);}return dp[(prices.length - 1) % 2][1];}
}- 时间复杂度：O(n)
- 空间复杂度：O(1)
优化空间（一维数组）：
class Solution {public int maxProfit(int[] prices) {int[] dp = new int[2];// 0表示持有，1表示卖出dp[0] = -prices[0];dp[1] = 0;for(int i = 1; i <= prices.length; i++){// 前一天持有; 既然不限制交易次数，那么再次买股票时，要加上之前的收益dp[0] = Math.max(dp[0], dp[1] - prices[i-1]);// 前一天卖出; 或当天卖出，当天卖出，得先持有dp[1] = Math.max(dp[1], dp[0] + prices[i-1]);}return dp[1];}
}123.买卖股票的最佳时机III
力扣题目链接(opens new window)
给定一个数组，它的第 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 <= 10^5
- 0 <= prices[i] <= 10^5
这道题目相对 121.买卖股票的最佳时机 和 122.买卖股票的最佳时机Ⅱ 难了不少。
关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。
接来下我用动态规划五部曲详细分析一下：
-
确定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] = Math.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] = Math.max(dp[i - 1][1] + prices[i], dp[i - 1][2]);
同理可推出剩下状态部分：
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]);
-
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数组
以输入[1,2,3,4,5]为例
大家可以看到红色框为最后两次卖出的状态。
现在最大的时候一定是卖出的状态，而两次卖出的状态现金最大一定是最后一次卖出。如果想不明白的也可以这么理解：如果第一次卖出已经是最大值了，那么我们可以在当天立刻买入再立刻卖出。所以 dp[4][4] 已经包含了 dp[4][2] 的情况。也就是说第二次卖出手里所剩的钱一定是最多的。
所以最终最大利润是dp[4][4]
以上五部都分析完了，不难写出如下代码：
class Solution {public int maxProfit(int[] prices) {int len = prices.length;// 边界判断, 题目中 length >= 1, 所以可省去if (prices.length == 0) return 0;/** 定义 5 种状态:* 0: 没有操作, 1: 第一次买入, 2: 第一次卖出, 3: 第二次买入, 4: 第二次卖出*/int[][] dp = new int[len][5];// 不需要初始化2、4因为Java数组默认初始化就是0dp[0][1] = -prices[0];// 初始化第二次买入的状态是确保 最后结果是最多两次买卖的最大利润dp[0][3] = -prices[0];for (int i = 1; i < len; i++) {dp[i][1] = Math.max(dp[i - 1][1], -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[len - 1][4];}
}- 时间复杂度：O(n)
- 空间复杂度：O(n × 5)
当然，还有一种优化空间写法：
class Solution {public int maxProfit(int[] prices) {int[] dp = new int[4]; // 存储两次交易的状态就行了// dp[0]代表第一次交易的买入dp[0] = -prices[0];// dp[1]代表第一次交易的卖出dp[1] = 0;// dp[2]代表第二次交易的买入dp[2] = -prices[0];// dp[3]代表第二次交易的卖出dp[3] = 0;for(int i = 1; i <= prices.length; i++){// 要么保持不变，要么没有就买，有了就卖dp[0] = Math.max(dp[0], -prices[i-1]);dp[1] = Math.max(dp[1], dp[0]+prices[i-1]);// 这已经是第二次交易了，所以得加上前一次交易卖出去的收获dp[2] = Math.max(dp[2], dp[1]-prices[i-1]);dp[3] = Math.max(dp[3], dp[2]+ prices[i-1]);}return dp[3];}
}- 时间复杂度：O(n)
- 空间复杂度：O(1)
大家会发现dp[2]利用的是当天的dp[1]。 但结果也是对的。
我来简单解释一下：
dp[1] = max(dp[1], dp[0] - prices[i]); 如果dp[1]取dp[1]，即保持买入股票的状态，那么 dp[2] = max(dp[2], dp[1] + prices[i]);中dp[1] + prices[i] 就是今天卖出。
如果dp[1]取dp[0] - prices[i]，今天买入股票，那么dp[2] = max(dp[2], dp[1] + prices[i]);中的dp[1] + prices[i]相当于是今天再卖出股票，一买一卖收益为0，对所得现金没有影响。相当于今天买入股票又卖出股票，等于没有操作，保持昨天卖出股票的状态了。
这种写法看上去简单，其实思路很绕，不建议大家这么写，这么思考，很容易把自己绕进去！
对于本题，把版本一的写法研究明白，足以！