股票买卖问题：贪心与动态规划解法详解

1. 题目背景与核心问题

这道题目来自力扣（LeetCode）的股票买卖系列问题，编号122。题目描述为：给定一个数组 prices，其中 prices[i] 表示某支股票第 i 天的价格。你可以尽可能地完成更多的交易（多次买卖一支股票），但必须在再次购买前出售掉之前的股票。要求计算你能获得的最大利润。

这个问题在实际投资中非常典型——它模拟了短线交易者在波动市场中的操作策略。与只能买卖一次的基础版本（121题）不同，本题允许无限次交易，这更接近现实中的日内交易场景。

2. 解题思路分析与算法选择

2.1 暴力搜索法的局限性

最直观的解法是尝试所有可能的买卖组合。对于n天的价格序列，存在2^(n-1)种可能的交易路径（每天可以选择持有或卖出）。这种O(2^n)时间复杂度的解法在n>20时就不可行了，而力扣的测试用例往往n>10^5。

注意：虽然回溯法理论上可行，但在算法题中遇到"尽可能多交易"的描述时，通常暗示存在更优解。

2.2 贪心算法的适用性证明

通过观察价格波动规律可以发现：总最大利润等于所有上升区间的累加。例如价格序列[1,3,5]的利润4=(3-1)+(5-3)，等同于(5-1)。这满足贪心选择性质——局部最优解能构成全局最优解。

数学证明：

1. 设p为连续上涨区间的起点，q为终点
2. 利润总和Σ(prices[i]-prices[i-1]) = prices[q]-prices[p]
3. 因此分段计算与整体计算结果一致

2.3 动态规划解法分析

虽然贪心算法更高效，但动态规划解法更具通用性，可以扩展到更复杂的交易限制场景（如含手续费、冷冻期等）。定义状态：

• dp[i][0]：第i天结束时未持有股票的最大利润
• dp[i][1]：第i天结束时持有股票的最大利润

状态转移方程：

python复制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])  # 保持持仓或买入

空间复杂度可优化到O(1)，因为每天的状态只依赖前一天。

3. 代码实现与优化技巧

3.1 贪心算法实现（Python）

python复制def maxProfit(prices):
    profit = 0
    for i in range(1, len(prices)):
        if prices[i] > prices[i-1]:
            profit += prices[i] - prices[i-1]
    return profit

时间复杂度：O(n) 单次遍历
空间复杂度：O(1) 常数空间

3.2 动态规划实现（Python）

python复制def maxProfit(prices):
    n = len(prices)
    dp = [[0]*2 for _ in range(n)]
    dp[0][1] = -prices[0]
    
    for i in range(1, n):
        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[-1][0]

空间优化版本：

python复制def maxProfit(prices):
    cash, hold = 0, -prices[0]
    for price in prices[1:]:
        cash, hold = max(cash, hold + price), max(hold, cash - price)
    return cash

3.3 边界条件处理技巧

1. 空输入处理：检查if not prices: return 0
2. 单日价格：直接返回0（无法交易）
3. 连续相同价格：不影响结果，但可以添加if prices[i] != prices[i-1]优化
4. 大数测试：Python无需特别处理，但其他语言需注意整数溢出

4. 复杂度分析与算法对比

贪心算法在本题中是最优解，但当问题变化时：

• 加入交易手续费：贪心可能失效
• 加入冷冻期：必须使用动态规划
• 限制交易次数：需三维DP

5. 常见错误与调试案例

5.1 典型错误模式

1. 峰值谷值误判：

python复制# 错误示例：只在全局最低点买入，最高点卖出
min_price, max_profit = float('inf'), 0
for price in prices:
    min_price = min(min_price, price)
    max_profit = max(max_profit, price - min_price)  # 只计算单次交易

2. 过度交易：

python复制# 错误示例：每天买卖（忽略手续费）
profit = 0
for i in range(1, len(prices)):
    profit += prices[i] - prices[i-1]  # 包含下跌日的负收益

5.2 测试用例设计

有效测试组合：

1. 单调递增：[1,2,3,4] → 3
2. 波动行情：[7,1,5,3,6,4] → 7
3. 平台期：[1,2,2,3] → 2
4. 极端情况：[7,6,4,3,1] → 0

5.3 调试技巧

1. 打印每日决策：

python复制for i in range(1, len(prices)):
    if prices[i] > prices[i-1]:
        print(f"Day {i}: Buy at {prices[i-1]}, Sell at {prices[i]}")
        profit += prices[i] - prices[i-1]

2. 可视化价格曲线：

python复制import matplotlib.pyplot as plt
plt.plot(prices)
plt.scatter(range(len(prices)), prices, c='r')
plt.show()

6. 实际应用与扩展思考

6.1 量化交易中的应用

在实际高频交易中，类似的策略被称为"趋势跟踪"：

• 当价格突破N日高点时买入
• 当价格跌破M日低点时卖出
• 需要加入滑点、手续费等现实因素考量

6.2 问题变种与解法

1. 含手续费（714题）：

python复制def maxProfit(prices, fee):
    cash, hold = 0, -prices[0]
    for price in prices[1:]:
        cash = max(cash, hold + price - fee)
        hold = max(hold, cash - price)
    return cash

2. 冷冻期（309题）：

python复制def maxProfit(prices):
    n = len(prices)
    if n < 2: return 0
    dp = [[0]*3 for _ in range(n)]  # 0:hold, 1:cooldown, 2:empty
    dp[0][0] = -prices[0]
    for i in range(1, n):
        dp[i][0] = max(dp[i-1][0], dp[i-1][2] - prices[i])
        dp[i][1] = dp[i-1][0] + prices[i]
        dp[i][2] = max(dp[i-1][2], dp[i-1][1])
    return max(dp[-1][1], dp[-1][2])

6.3 算法选择建议

对于面试场景：

1. 先提出暴力解法
2. 分析问题特性
3. 给出贪心解法并证明
4. 讨论动态规划方案
5. 比较两种方法的优劣

在实际开发中，建议使用动态规划框架，虽然本题中贪心更高效，但DP的代码结构更容易适应需求变更。比如当产品经理突然要求加入0.1%的手续费时，贪心算法可能需要完全重写，而DP只需修改一个参数。