LeetCode 122. 买卖股票的最佳时机 II（中等）

最新推荐文章于 2025-06-12 07:28:24 发布

枫景Maple

最新推荐文章于 2025-06-12 07:28:24 发布

阅读量811

点赞数 10

CC 4.0 BY-SA版权

分类专栏：算法文章标签： leetcode 算法

本文链接：https://blog.youkuaiyun.com/ZeroBugX/article/details/146122528

算法专栏收录该内容

23 篇文章

订阅专栏

题目描述

给你一个整数数组 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 * 10^4
0 <= prices[i] <= 10^4

问题分析

与"买卖股票的最佳时机 I"不同，这道题允许我们进行多次交易，但有以下限制：

在任何时候最多只能持有一股股票
必须先买入才能卖出（不能卖空）
可以在同一天买入并卖出

关键问题是：如何安排买入和卖出的时机，使得总利润最大？

解题思路

贪心算法

这道题有一个非常直观的贪心解法。由于可以进行无限次交易，我们可以采取"只要有利可图就交易"的策略。具体来说：

当股票价格上涨时（明天价格 > 今天价格），我们应该在今天买入，明天卖出，赚取差价

当股票价格下跌时，我们不进行任何操作

这个策略可以进一步简化：只需要将所有相邻两天的价格上涨都累加起来，就得到了最大利润。

例如，对于数组 [1,2,3,4,5]：

第1天买入，第5天卖出，利润是 5-1=4

等价于：(2-1)+(3-2)+(4-3)+(5-4)=4

即将所有上涨的部分都累加起来，就是最大利润。

为什么贪心算法有效？

假设我们有三天的价格：a, b, c，其中 a < b > c（即价格先上涨后下跌）。

如果我们在价格为a时买入，在价格为b时卖出，然后在价格为c时再买入，总利润为(b-a)。

如果我们选择持有（即在价格为a时买入，一直持有到价格为c），利润为(c-a)，由于c<b，所以(c-a)<(b-a)，不如前一种策略获利多。

代码实现

Java 实现

class Solution {
    public int maxProfit(int[] prices) {
        // 边界条件检查
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        
        int totalProfit = 0;
        
        // 遍历价格数组
        for (int i = 1; i < prices.length; i++) {
            // 如果当前价格高于前一天的价格，就进行交易
            if (prices[i] > prices[i - 1]) {
                // 累加这一天的利润
                totalProfit += prices[i] - prices[i - 1];
            }
        }
        
        return totalProfit;
    }
}

我们还可以添加一些调试信息，以便更清楚地理解算法的执行过程：

class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        
        int totalProfit = 0;
        System.out.println("初始总利润: " + totalProfit);
        
        for (int i = 1; i < prices.length; i++) {
            int todayPrice = prices[i];
            int yesterdayPrice = prices[i - 1];
            
            if (todayPrice > yesterdayPrice) {
                int profit = todayPrice - yesterdayPrice;
                totalProfit += profit;
                System.out.println("第" + i + "天: 价格从 " + yesterdayPrice + 
                                  " 上涨到 " + todayPrice + ", 获利 " + profit + 
                                  ", 总利润增加到 " + totalProfit);
            } else {
                System.out.println("第" + i + "天: 价格从 " + yesterdayPrice + 
                                  " 下跌到 " + todayPrice + ", 不操作, 总利润仍为 " + 
                                  totalProfit);
            }
        }
        
        return totalProfit;
    }
}

输入：prices = [7,1,5,3,6,4]

初始总利润: 0
第1天: 价格从 7 下跌到 1, 不操作, 总利润仍为 0
第2天: 价格从 1 上涨到 5, 获利 4, 总利润增加到 4
第3天: 价格从 5 下跌到 3, 不操作, 总利润仍为 4
第4天: 价格从 3 上涨到 6, 获利 3, 总利润增加到 7
第5天: 价格从 6 下跌到 4, 不操作, 总利润仍为 7

C# 实现

public class Solution {
    public int MaxProfit(int[] prices) {
        // 边界条件检查
        if (prices == null || prices.Length <= 1) {
            return 0;
        }
        
        int totalProfit = 0;
        
        // 遍历价格数组
        for (int i = 1; i < prices.Length; i++) {
            // 如果当前价格高于前一天的价格，就进行交易
            if (prices[i] > prices[i - 1]) {
                // 累加这一天的利润
                totalProfit += prices[i] - prices[i - 1];
            }
        }
        
        return totalProfit;
    }
}

详细执行过程图解

以示例 [7,1,5,3,6,4] 为例，让我们详细跟踪算法的执行过程：

初始总利润：0

第1天 → 第2天：价格从 7 下跌到 1，不操作，总利润仍为 0

第2天 → 第3天：价格从 1 上涨到 5，进行交易：

第2天买入（价格=1）

第3天卖出（价格=5）

获利：5-1=4

总利润：0+4=4

第3天 → 第4天：价格从 5 下跌到 3，不操作，总利润仍为 4

第4天 → 第5天：价格从 3 上涨到 6，进行交易：

第4天买入（价格=3）

第5天卖出（价格=6）

获利：6-3=3

总利润：4+3=7

第5天 → 第6天：价格从 6 下跌到 4，不操作，总利润仍为 7

最终总利润：7

价格-时间图解

股票价格变化图：

 价格
  ^
7 | *
6 |             *
5 |       *       
4 |                *
3 |          *   
2 |            
1 |    *       
0 +-------------------> 时间
    1  2  3  4  5  6

交易策略图解：

 价格
  ^
7 |*
6 |            *卖出
5 |       *卖出   
4 |               *
3 |          *买入
2 |            
1 |    *买入    
0 +-----------------> 时间
    1  2  3  4  5  6

算法分析

贪心算法的正确性

为什么这个贪心策略是正确的？我们可以证明，对于任何一段连续上涨的区间[i, j]，在i买入，在j卖出的利润等于区间内所有相邻两天价格差的总和：

prices[j] - prices[i] = (prices[i+1] - prices[i]) + (prices[i+2] - prices[i+1]) + ... + (prices[j] - prices[j-1])

因此，无论是选择在整个上涨区间买卖一次，还是每天都进行买卖，最终的利润是相同的。而对于下跌区间，不进行操作是最优的。

复杂度分析

时间复杂度：O(n)，其中 n 是价格数组的长度。我们只需要遍历一次数组。

空间复杂度：O(1)，只使用了常数额外空间。

动态规划解法

虽然贪心算法已经能够解决这个问题，但我们也可以使用动态规划的思路来解决。这种方法对于理解更复杂的股票问题很有帮助。

定义状态：

dp[i][0]：第i天交易结束后不持有股票的最大利润

dp[i][1]：第i天交易结束后持有股票的最大利润

状态转移方程：

dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])（今天不持有 = max(昨天不持有，昨天持有今天卖出)）

dp[i][1] = max(dp[i-1][1], dp[i-1][0] - prices[i])（今天持有 = max(昨天持有，昨天不持有今天买入)）

初始状态：

dp[0][0] = 0（第0天不持有股票，利润为0）

dp[0][1] = -prices[0]（第0天持有股票，利润为-prices[0]）

最终答案是 dp[n-1][0]，即最后一天不持有股票的最大利润。

Java实现：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if (n <= 1) return 0;
        
        int[][] dp = new int[n][2];
        
        // 初始状态
        dp[0][0] = 0;            // 第0天不持有股票
        dp[0][1] = -prices[0];   // 第0天持有股票
        
        // 状态转移
        for (int i = 1; i < n; i++) {
            // 今天不持有 = max(昨天不持有，昨天持有今天卖出)
            dp[i][0] = Math.max(dp[i-1][0], dp[i-1][1] + prices[i]); 
            // 今天持有 = max(昨天持有，昨天不持有今天买入)
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0] - prices[i]);
        }
        
        return dp[n-1][0];  // 最后一天不持有股票的最大利润
    }
}

空间优化的动态规划（因为只依赖前一天的状态）：

class Solution {
    public int maxProfit(int[] prices) {
        int n = prices.length;
        if (n <= 1) return 0;
        
        int noStock = 0;           // 不持有股票的最大利润
        int hasStock = -prices[0]; // 持有股票的最大利润
        
        for (int i = 1; i < n; i++) {
            int prevNoStock = noStock;
            // 今天不持有 = max(昨天不持有，昨天持有今天卖出)
            noStock = Math.max(noStock, hasStock + prices[i]);
            // 今天持有 = max(昨天持有，昨天不持有今天买入)
            hasStock = Math.max(hasStock, prevNoStock - prices[i]);
        }
         
        return noStock;
    }
}