7.＜ tag-动态规划和买卖股票合集＞lt.121. 买卖股票的最佳时机 + lt.122.买卖股票的最佳时机 II+ lt.123. 买卖股票的最佳时机 III dbc

本文链接：https://blog.csdn.net/nmsLLCSDN/article/details/125889592

本文深入探讨了三种股票交易问题的解决方案：121.买卖股票的最佳时机、122.买卖股票的最佳时机II和123.买卖股票的最佳时机III。通过贪心算法和动态规划，分析了不同限制条件下获得最大利润的策略。代码实现详细展示了如何运用递推公式和状态转移来求解这些问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

lt.121. 买卖股票的最佳时机

[案例需求]

在这里插入图片描述

[思路分析一, 贪心]

因为股票就买卖一次，那么贪心的想法很自然就是取最左最小值，取最右最大值，那么得到的差值就是最大利润。

[代码实现]

class Solution {
    public int maxProfit(int[] prices) {
        //1. 贪心. 找到最小最大值
        int min = Integer.MAX_VALUE;
        int res = Integer.MIN_VALUE;

        int len = prices.length;

        for(int i = 0; i < len; i++){
            min = Math.min(min, prices[i]);
            res = Math.max(res, prices[i] - min);
        } 
        return res;
    }
}

在这里插入图片描述

[思路分析二, 动态规划]

确定dp数组以及下标

dp[i][0] 表示第i天持有股票所得最多现金, 这里可能有同学疑惑，本题中只能买卖一次，持有股票之后哪还有现金呢？其实一开始现金是0，那么加入第i天买入股票现金就是 -prices[i]，这是一个负数。
dp[i][1] 表示第i天不持有股票所得最多的现金。注意这里说的是“持有”，“持有”不代表就是当天“买入”！也有可能是昨天就买入了，今天保持持有的状态. 很多同学把“持有”和“买入”没分区分清楚。

dp[i][x] 是第i天持有或不持有股票时, 得到的现金!!! dp是可以得到的现金!!! 如果持有股票, 那么拥有的现金是负的, 因为用现金买的股票还没卖呢!还在持有!!! 此时 dp[i][0] < 0; 相反, dp[i][1] 表示不再持有股票, 所以现金是正的!

确定递推公式
a. 如果第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]);

b. 如果第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 {
    public int maxProfit(int[] prices) {
        //1. 确定dp[i][x]
        //1.1 dp[i][0] 表示持有股票第i天时的现金, 
        //1.2 dp[i][1] 表示在第i天不持有股票时的现金
        int len = prices.length;
        int[][] dp = new int[len][2];

        //2. 确定递推公式;
        //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]);    
        
        //3.初始化
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        for(int i = 1; i < len; i++){
            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]);   
        }

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

lt.122.买卖股票的最佳时机 II

[案例需求]

在这里插入图片描述

[思路分析一, 贪心]

只要今天的股价比昨天的高我就卖出, 然后把今天和昨天累加的利润加起来你返回即可。

[代码实现]

class Solution {
    public int maxProfit(int[] prices) {
        //遍历数组, 每两个数如果是递增的, 卖出, 然后累加到res上
        int len = prices.length;
        int res = 0;

        for(int i = 1; i < len; i++){
            if(prices[i] > prices[i - 1]){
                res += (prices[i] - prices[i - 1]);
            }
        }

        return res;
    }
}

[思路分析二, 动态规划]

本题和121. 买卖股票的最佳时机的唯一区别本题股票可以买卖多次了（注意只有一只股票，所以再次购买前要出售掉之前的股票）
在动规五部曲中，这个区别主要是体现在递推公式上，其他都和121. 买卖股票的最佳时机一样一样的。

强调一下dp数组的含义:

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

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

第i - 1天就持有股票,那么就保持现状，所得现金就是昨天持有股票的所得现金 dp[i][0] = dp[i - 1][0]
第i - 1天还未持有股票, 所得现金就是昨天不持有股票的所得现金减去今天的股票价格 dp[i][0] = dp[i - 1][1] - prices[i]

[代码实现]

class Solution {
    public int maxProfit(int[] prices) {
        //1. 确定dp[i][x]
        //1.1 dp[i][0] 表示持有股票第i天时的现金, 
        //1.2 dp[i][1] 表示在第i天不持有股票时的现金
        int len = prices.length;
        int[][] dp = new int[len][2];

        //2. 确定递推公式;
        //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]);    
        
        //3.初始化
        dp[0][0] = -prices[0];
        dp[0][1] = 0;

        for(int i = 1; i < len; 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], prices[i] + dp[i - 1][0]);   
        }

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

lt.123. 买卖股票的最佳时机 III

[案例需求]

在这里插入图片描述

[思路分析]

这道题目相对 121.买卖股票的最佳时机和 122.买卖股票的最佳时机II难了不少。
关键在于至多买卖两次，这意味着可以买卖一次，可以买卖两次，也可以不买卖。

动规五步法

确定dp数组以及下标的含义
一天共有五种不同的状态:

没有操作; 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][1]
第i天正好是当天第一次买入股票: dp[i][1] = dp[i - 1][0] - prices[i]
那么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][2]
第i天正好是当天第一次卖出股票: dp[i][2] = dp[i - 1][1] + prices[i]
所以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数组如何初始化

确定遍历顺序
从递归公式其实已经可以看出，一定是从前向后遍历，因为dp[i]，依靠dp[i - 1]的数值。

举例推导dp数组

[代码实现]

class Solution {
    public int maxProfit(int[] prices) {
        //1. 确定dp数组, dp[i][0~4] 
        // 在第i天, 五种状态下持有的现金数量
        //0: 无操作 
        //1:  第一次买入
        //2:  第一次卖出
        //3:    第二次买入
        //4:    第二次卖出
        int len = prices.length;
        int[][] dp = new int[len][5];

        //2. 确定递推公式:
        // 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]);

        //3. 初始值;
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        dp[0][2] = 0;
        dp[0][3] = -prices[0];
        dp[0][4] = 0;

        //4. 确定遍历: 正序,. dp[i] 需要dp[i - 1]的状态
        for(int i = 1; i < len; 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[len - 1][4];
    }
}

待补充