代码随想录day41 ||股票问题

股票问题Ⅰ

力扣题目链接

题目描述：

给定一个数组 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贪心算法：

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;
    }
};

代码2动态规划

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0)return 0;
        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.size();i++){
            dp[i][0]=max(dp[i-1][0],-prices[i]);
            dp[i][1]=max(dp[i-1][1],dp[i-1][0]+prices[i]);
        }
        return dp[len-1][1];
    }
};

 

1，确定dp数组（dp table）以及下标的含义

dp[i][0] 表示第i天持有股票所得最多现金 ，这里可能有同学疑惑，本题中只能买卖一次，持有股票之后哪还有现金呢？

其实一开始现金是0，那么加入第i天买入股票现金就是 -prices[i]， 这是一个负数。

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

注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态

很多同学把“持有”和“买入”没区分清楚。

在下面递推公式分析中，我会进一步讲解。

2，确定递推公式

如果第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]);

这样递推公式我们就分析完了

3，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;

4，确定遍历顺序

从递推公式可以看出dp[i]都是由dp[i - 1]推导出来的，那么一定是从前向后遍历。

5，举例推导dp数组

以示例1，输入：[7,1,5,3,6,4]为例，dp数组状态如下：

dp[5][1]就是最终结果。

 

股票问题Ⅱ

力扣题目链接

题目描述：

给你一个整数数组 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贪心算法：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int result = 0;
        for (int i = 1; i < prices.size(); i++) {
            result += max(prices[i] - prices[i - 1], 0);
        }
        return result;
    }
};

只计算上升的波段 ，下降的波段不计算

代码2贪心算法

 

class Solution {  
public:  
    int maxProfit(vector<int>& prices) {  
        int result = 0; // 初始化累计利润为0  
        
        // 遍历每一天的价格  
        for (int i = 0; i < prices.size(); i++) {  
            int j = 0;   
            int temp = 0; // 临时变量，用于计算当前买卖的利润  
            
            // 内层循环寻找价格下降的点  
            for (j = i; j < prices.size() - 1; j++) {  
                // 如果发现价格下降，则停止继续寻找  
                if (prices[j + 1] < prices[j]) {  
                    break;  
                }  
            }  
            
            // 计算这段时间内的利润：卖出价格 - 买入价格  
            temp = prices[j] - prices[i];  
            // 累计到总利润中  
            result += temp;  
            // 更新i以避免重复计算  
            i = j;  
        }  
        
        // 返回计算出的最大利润  
        return result;  
    }  
};

代码3动态规划：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len=prices.size();
        if(len==0)return 0;
        vector<vector<int>> dp(len,vector<int>(2));
        dp[0][0]=-prices[0];
        dp[0][1]=0;
        for(int i=1;i<prices.size();i++){
            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[len-1][1];
    }
};

 

• 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]

注意这里和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]。

也就是从1-->0的过程，从有到无，如果是dp[i][0]=dp[i-1][1]-prices[i];*/

再来看看如果第i天不持有股票即dp[i][1]的情况， 依然可以由两个状态推出来

• 第i-1天就不持有股票，那么就保持现状，所得现金就是昨天不持有股票的所得现金 即：dp[i - 1][1]
• 第i天卖出股票，所得现金就是按照今天股票价格卖出后所得现金即：prices[i] + dp[i - 1][0]

注意这里和121. 买卖股票的最佳时机 (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

代码

class Solution {  
public:  
    int maxProfit(vector<int>& prices) {  
        if (prices.size() == 0) return 0;  
        vector<vector<int>> dp(prices.size(), vector<int>(5, 0));  
        
        dp[0][1] = -prices[0];  
        dp[0][3] = -prices[0];  
        
        // 输出初始状态  
        printDP(dp, 0);  

        for (int i = 1; i < prices.size(); i++) {  
            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]);  

            // 输出当前天的dp状态  
            printDP(dp, i);  
        }  
        
        return dp[prices.size() - 1][4];  
    }  
    
    void printDP(const vector<vector<int>>& dp, int day) {  
        cout << "Day " << day << ": ";  
        for (int i = 0; i < 5; ++i) {  
            cout << dp[day][i] << " ";  
        }  
        cout << endl;  
    }  
};  

状态定义

在解决这个问题的过程中，我们用一个二维数组 dp[i][j] 来表示在第 i 天的状态，其中 j 从0到4表示不同的状态：

• dp[i][0]: 第 i 天没有做任何交易，且不持有股票。
• dp[i][1]: 第 i 天进行了第一次交易持有股票（相当于买了一次）。
• dp[i][2]: 第 i 天完成了第一次交易（买入并卖出，结束手上没有股票）。
• dp[i][3]: 第 i 天进行了第二次交易持有股票（第二次买入）。
• dp[i][4]: 第 i 天完成了第二次交易（第二次交易也结束，不持有股票）。

转移方程

对于每一个 i 天具体的状态 j，我们有以下状态转移，匹配每一步：

• dp[i][0]: 始终为0，表示没有交易。
• dp[i][1]: max(dp[i-1][1], dp[i-1][0] - prices[i])
  • 要么保持前一天的持股状态 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-1][2]，要么在今天将昨天持股卖掉：dp[i-1][1] + prices[i]。
• dp[i][3]: max(dp[i-1][3], dp[i-1][2] - prices[i])
  • 要么保持昨天的持股状态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[i-1][4]，要么在今天卖出，即完成第二次交易：dp[i-1][3] + prices[i]。

初始条件

在第 0 天的初始状态：

• dp[0][0] = 0：没有交易
• dp[0][1] = -prices[0]：买入一次
• dp[0][2] = 0：第一次交易完成，这实际上不可能在第0天完成，所以初始为0
• dp[0][3] = -prices[0]：第二次购买，和第一次一样也在第0天是不可能的，所以初始为-prices[0]
• dp[0][4] = 0：这一状态表示真正完成两次卖出，这也在0天时不可能。

结果

最终希望的结果是最后一天的 dp[n-1][4]，因为这是进行最多两次交易并且持仓为0的最大利润状态，即 dp[prices.size() - 1][4]。

通过上面步骤逐步理解动态规划数组变化，每增加一天新状态会根据前一天的状态更新新最大利润。你可以通过再次运行程序结合此解释查看每天dp数组的变化，观察每个状态是如何更新的。这样有助于理解从开始到结束整个赚取最大利润的过程。

 

---

---

输入 prices = [3,3,5,0,0,3,1,4]

标准输出

Day 0: 0 -3 0 -3 0
Day 1: 0 -3 0 -3 0
Day 2: 0 -3 2 -3 2
Day 3: 0 0 2 2 2
Day 4: 0 0 2 2 2
Day 5: 0 0 3 2 5
Day 6: 0 0 3 2 5
Day 7: 0 0 4 2 6  

初始状态（第0天）

• 价格是 3。
• dp[0][0] = 0: 无交易且无持股。
• dp[0][1] = -prices[0] = -3: 第一次买入。
• dp[0][2] = 0: 第一次卖出，此时交易未发生。
• dp[0][3] = -prices[0] = -3: 第二次买入，实际上不现实。
• dp[0][4] = 0: 第二次卖出，交易未发生。

输出：

Day 0: 0 -3 0 -3 0

第1天

• 价格是 3。
• dp[1][0] = dp[0][0] = 0: 没有进行任何交易。
• dp[1][1] = max(dp[0][1], dp[0][0] - prices[1]) = max(-3, -3) = -3: 保持持股或再次买入。
• dp[1][2] = max(dp[0][2], dp[0][1] + prices[1]) = max(0, 0) = 0: 保持无持股或卖出。
• dp[1][3] = max(dp[0][3], dp[0][2] - prices[1]) = max(-3, -3) = -3: 保持持股或再次买入。
• dp[1][4] = max(dp[0][4], dp[0][3] + prices[1]) = max(0, 0) = 0: 保持无持股或卖出。

输出：

Day 1: 0 -3 0 -3 0

第2天

• 价格是 5。
• dp[2][1] = max(dp[1][1], dp[1][0] - prices[2]) = max(-3, -5) = -3: 保持持股或再次买入。
• dp[2][2] = max(dp[1][2], dp[1][1] + prices[2]) = max(0, 2) = 2: 保持无持股或卖出。
• dp[2][3] = max(dp[1][3], dp[1][2] - prices[2]) = max(-3, -5) = -3: 保持持股或再次买入。
• dp[2][4] = max(dp[1][4], dp[1][3] + prices[2]) = max(0, 2) = 2: 保持无持股或卖出。

输出：

Day 2: 0 -3 2 -3 2

第3天

• 价格是 0。
• dp[3][1] = max(dp[2][1], dp[2][0] - prices[3]) = max(-3, 0) = 0: 买入时成本降低。
• dp[3][2] = max(dp[2][2], dp[2][1] + prices[3]) = max(2, -3) = 2: 无持股（收益不变）。
• dp[3][3] = max(dp[2][3], dp[2][2] - prices[3]) = max(-3, 2) = 2: 买入时成本降低。
• dp[3][4] = max(dp[2][4], dp[2][3] + prices[3]) = max(2, -3) = 2: 无持股（收益不变）。

输出：

Day 3: 0 0 2 2 2

第4天

• 价格是 0。
• dp[4][1] = max(dp[3][1], dp[3][0] - prices[4]) = max(0, 0) = 0: 无变化。
• dp[4][2] = max(dp[3][2], dp[3][1] + prices[4]) = max(2, 0) = 2: 无变化。
• dp[4][3] = max(dp[3][3], dp[3][2] - prices[4]) = max(2, 2) = 2: 无变化。
• dp[4][4] = max(dp[3][4], dp[3][3] + prices[4]) = max(2, 2) = 2: 无变化。

输出：

Day 4: 0 0 2 2 2

第5天

• 价格是 3。
• dp[5][1] = max(dp[4][1], dp[4][0] - prices[5]) = max(0, -3) = 0: 无变化。
• dp[5][2] = max(dp[4][2], dp[4][1] + prices[5]) = max(2, 3) = 3: 卖出获取利润。
• dp[5][3] = max(dp[4][3], dp[4][2] - prices[5]) = max(2, -1) = 2: 无变化。
• dp[5][4] = max(dp[4][4], dp[4][3] + prices[5]) = max(2, 5) = 5: 卖出获取利润。

输出：

Day 5: 0 0 3 2 5

第6天

• 价格是 1。
• dp[6][1] = max(dp[5][1], dp[5][0] - prices[6]) = max(0, -1) = 0: 无变化。
• dp[6][2] = max(dp[5][2], dp[5][1] + prices[6]) = max(3, 1) = 3: 无变化。
• dp[6][3] = max(dp[5][3], dp[5][2] - prices[6]) = max(2, 2) = 2: 无变化。
• dp[6][4] = max(dp[5][4], dp[5][3] + prices[6]) = max(5, 3) = 5: 无变化。

输出：

Day 6: 0 0 3 2 5

第7天

• 价格是 4。
• dp[7][1] = max(dp[6][1], dp[6][0] - prices[7]) = max(0, -4) = 0: 无变化。
• dp[7][2] = max(dp[6][2], dp[6][1] + prices[7]) = max(3, 4) = 4: 卖出获取更多的利润。
• dp[7][3] = max(dp[6][3], dp[6][2] - prices[7]) = max(2, -1) = 2: 无变化。
• dp[7][4] = max(dp[6][4], dp[6][3] + prices[7]) = max(5, 6) = 6: 卖出获取更多的利润。

输出：

Day 7: 0 0 4 2 6

总结：

• 最终在第7天， dp[n-1][4] = dp[7][4] = 6。我们进行了最高利润的两次交易操作，最大利润为6

这个动态规划的精髓在于通过状态转移方程，逐步积累并比较每一天的最大可能利润，以最优子结构为基础，构建整个问题的最优解，即在每次最多两次交易中最大化利润。