【代码随想录训练营第42期 Day41打卡 - 买卖股票问题 - LeetCode 121. 买卖股票的最佳时机 122.买卖股票的最佳时机II 123.买卖股票的最佳时机III-CSDN博客

给定一个数组 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

题解1：暴力--超时

没有技巧，一一比较。

题解2：贪心

上述已经提到，贪心策略就是：在价格上升时买入，在价格下降前卖出。

在这里也就对应着：数组开始递减的时候找最小值，只有开始递增的时候计算差值。

最小值需要不断更新，这里的最小值记录当前遍历到的最小价格，随着天数的遍历不断更新；而最终的结果，就是所有差值比较后最大的差值。-- 我们可以通过一个循环实现比较过程。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int minprice = prices[0];        //记录当前遍历到的最小价格，初始化为第一天的价格
        int ans = 0;        //记录最大利润
        for (int i = 0; i < n; i++) {
            if (prices[i] > minprice) {             //递增的时候计算差值
                ans = max(ans, prices[i] - minprice);
            }
            else    minprice = prices[i];       //递减的时候找最小值
        }
        return ans;
    }
};

题解3：动态规划--基于贪心的思路

和贪心思路相同，但在这里用dp数组记录最大利润。

dp[i] 表示前 i 天可以获得的最大利润。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0)     return 0; 
        vector<int> dp(n, 0);           //dp[i]表示前i天可以获得的最大利润，初始化dp数组 -- dp[0] = 0
        int minPrice = prices[0];           //初始化最小价格为第一天的价格
        for (int i = 1; i < n; i++) {
            minPrice = min(minPrice, prices[i]);    //更新最小价格
            dp[i] = max(dp[i - 1], prices[i] - minPrice);       //计算并更新dp[i]：第i天不卖--保留前一天最大利润dp[i - 1]；第i天卖--prices[i] - minprice
        }
        return dp[n - 1];       //所有天可以获得的最大利润
    }
};

题解4：动态规划--通解

这就是上述解题思路提到的动态规划的方法。这种方法对于买卖股票问题具有普适性，同类问题，相当于可用同一套模板来解决。

首先定义二维dp数组dp[i][j]：vector<vector<int>> dp(n, vector<int>(2));

这里共有两种状态，一是持有股票，而是不持有股票。

dp[i][0]表示第i天持有股票的最大利润，dp[i][1]表示第i天不持有股票的最大利润。

然后初始化dp数组第0天（实际情况的第一天）：

1. dp[0][0] -= prices[0]：持有股票，只买，利润为负，为 -prices[0] ；

2. dp[0][1] = 0：不持股票，没有买或卖，为0。

最后确定递推公式：

1.第 i 天持有股票：dp[i][0] = max(dp[i - 1][0], -prices[i])：要么是前一天就持有股票，要么是今天买入（直接用负的今天价格表示）；

2.第 i 天不持有股票：dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0])：要么是前一天就不持有股票，要么是今天卖出（前一天持有股票的利润加上今天的价格）。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0)     return 0;
        vector<vector<int>> dp(n, vector<int>(2));      //二维dp：dp[i][0]表示第i天持有股票的最大利润，dp[i][1]表示第i天不持有股票的最大利润
        dp[0][0] = -prices[0];          //初始化第0天：持有股票，只买，利润为负，为 -prices[0]；不持股票，没有买或卖，为0
        dp[0][1] = 0;               
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], -prices[i]);         //第i天持有股票的最大利润：要么是前一天就持有股票，要么是今天买入（直接用负的今天价格表示）
            dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);     //第i天不持有股票的最大利润：要么是前一天就不持有股票，要么是今天卖出（前一天持有股票的利润加上今天的价格）
        }
        return dp[n - 1][1];        //返回最后一天不持有股票的最大利润--已卖光
    }
};

题目二：122.买卖股票的最佳时机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

题解1：贪心

这道题曾在贪心章节打卡练习过，第二次看到就感觉比较简单了。

一句话总结贪心策略：我们可以把跨越多天的买卖等价理解成多个相邻两天的买卖--当后者大于前者时，就买前者，卖后者--我们将跨越多天的买卖等价于不断地买，然后卖，然后再买，再卖。（注意这里是可以等价于当天卖了再买）

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int ans = 0;
        for (int i = 0; i < n - 1; i++) {
            if (prices[i + 1] > prices[i]) {        //我们可以把跨越多天的买卖等价理解成多个相邻两天的买卖 
                ans += prices[i + 1] - prices[i];
            }
        }
        return ans;
    }
};

题解2：动态规划

依旧是刚刚的通解思路--可当做模板。

这里依旧是：dp[i][0]表示第i天（实际的i + 1天）持有股票的最大利润，dp[i][1]表示第i天不持有股票的最大利润。

这道题和上一题唯一的区别就在于递归方程上面：

1. 第 i 天持有股票的最大利润：dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i])：要么是前一天就持有股票，要么是今天刚买入；
2. 第 i 天不持有股票的最大利润：dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i])：要么是前一天就不持有股票，要么是今天卖出。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(2, 0));    //dp[i][0]表示第i天（实际的i + 1天）持有股票的最大利润，dp[i][1]表示第i天不持有股票的最大利润
        /*  初始化第0天（实际中的第一天）  */
        dp[0][0] = -prices[0];          //持有股票，只买，利润为 -prices[0]
        dp[0][1] = 0;           //没有买卖，利润为0
        /*  DP  */
        for (int i = 1; i < n; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);     //第i天持有股票的最大利润：要么是前一天就持有股票，要么是今天刚买入
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + prices[i]);     //第i天不持有股票的最大利润：要么是前一天就不持有股票，要么是今天卖出
        }
        return dp[n - 1][1];       //返回最后一天不持有股票的最大利润--已卖光
    }
};

题目三：123.买卖股票的最佳时机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][j] 数组，i 表示天数，j 表示状态。其实这样一来，这道题也变得清晰了，只是状态由两种变成了五种。

j 的状态定义如下：

0 - 没有操作

1 - 第一次买入

2 - 第一次卖出

3 - 第二次买入

4 - 第二次卖出

剩下的就跟前两道题思路做法一致了，这里直接看代码（附有详细注释）。

代码如下：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        if (n == 0 || n == 1) {             //先考虑特殊情况
            return 0;
        } 
        vector<vector<int>> dp(n, vector<int>(5, 0));       // dp[i][j]表示第i天处于状态j时的最大利润（j有5种状态）
        // 初始化第一天（i = 0）的dp数组状态
        dp[0][1] = -prices[0];     //第一次买入
        dp[0][3] = -prices[0];     //第二次买入
        for (int i = 1; i < n; i++) {
            dp[i][0] = dp[i - 1][0];        //第i天没有操作，利润不变
            dp[i][1] = max(dp[i - 1][1], -prices[i]);     //表示第i天（是否选择）第一次买入股票：取前一天第一次买入的利润和今天第一次买的利润的最大值
            dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + prices[i]);          //第一次卖：取前一天第一次卖出的利润和今天卖出后的利润的最大值--即选择是否在第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[n - 1][4];       //返回最后一天第二次卖出的最大利润 -- 注意：不是刚好就一定最后一天第二次卖出，而是最后一天之前（含最后一天），有第二次卖出
    }
};