动态规划与贪心算法详解：原理、对比与代码实践

本文深入剖析动态规划和贪心算法的核心思想，通过典型问题示例和详细代码实现，帮助开发者掌握这两种重要算法的应用场景与实现技巧

引言：算法选择的艺术

在算法设计中，动态规划（Dynamic Programming）和贪心算法（Greedy Algorithm）是解决最优化问题的两大核心策略。它们都能高效解决许多复杂问题，但适用场景和实现原理却大不相同。本文将深入探讨这两种算法，通过经典问题示例和代码实现，帮助你理解它们的本质差异和应用场景。

一、动态规划：分治思想的进阶

1.1 核心思想与特点

动态规划通过将复杂问题分解为相互重叠的子问题，并存储子问题的解（记忆化）来避免重复计算，最终构建出原问题的解。其核心特点包括：

• 最优子结构：问题的最优解包含其子问题的最优解
• 重叠子问题：递归求解时会反复遇到相同子问题
• 状态转移方程：定义问题状态与状态之间的关系

1.2 经典问题：0-1背包问题

问题描述：给定一组物品，每个物品有重量和价值，在不超过背包承重的前提下，如何选择物品使总价值最大？

动态规划解法

1. 定义状态 ：dp[i][w] 表示考虑前 i 个物品，在背包容量为 w 时可获得的最大价值
2. 状态转移方程 ：
   • 若当前物品重量 > 剩余容量：dp[i][w] = dp[i-1][w]
   • 否则：dp[i][w] = max(dp[i-1][w], dp[i-1][w - weight[i]] + value[i])
3. 初始化 ：dp[0][w] = 0（没有物品时价值为0）

代码实现

def knapsack_01(weights, values, capacity):
    n = len(weights)
    # 初始化DP表 (n+1) x (capacity+1)
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]
    
    # 构建DP表
    for i in range(1, n + 1):
        for w in range(1, capacity + 1):
            # 当前物品重量大于背包容量时，不能选择
            if weights[i-1] > w:
                dp[i][w] = dp[i-1][w]
            else:
                # 选择当前物品或不选择的较大值
                dp[i][w] = max(dp[i-1][w], 
                              dp[i-1][w - weights[i-1]] + values[i-1])
    
    # 回溯找出选择的物品
    selected = []
    w = capacity
    for i in range(n, 0, -1):
        if dp[i][w] != dp[i-1][w]:
            selected.append(i-1)
            w -= weights[i-1]
    
    return dp[n][capacity], selected

# 示例使用
weights = [2, 3, 4, 5]  # 物品重量
values = [3, 4, 5, 6]   # 物品价值
capacity = 8             # 背包容量

max_value, selected_items = knapsack_01(weights, values, capacity)
print(f"最大价值: {max_value}")
print(f"选中的物品索引: {selected_items}")

执行结果

最大价值: 10
选中的物品索引: [3, 1]  # 选择第2个(价值4)和第4个(价值6)物品

1.3 动态规划优化技巧

• 空间优化：使用一维数组代替二维数组（需反向遍历）
• 记忆化搜索：自顶向下的递归实现，适合子问题不全部使用的情况
• 状态压缩：当状态转移仅依赖有限前状态时，可压缩存储空间

二、贪心算法：局部最优的全局追求

2.1 核心思想与特点

贪心算法在每一步选择中都采取当前状态下最优的选择，希望导致全局最优解。其特点包括：

• 贪心选择性质：局部最优选择能导致全局最优解
• 无后效性：当前选择不影响后续子问题的结构
• 高效性：通常时间复杂度低于动态规划

2.2 经典问题：分数背包问题

问题描述：与0-1背包类似，但物品可以分割，求不超过背包容量时的最大价值。

贪心解法思路

1. 计算每个物品的单位重量价值（价值/重量）
2. 按照单位价值降序排序
3. 依次选择单位价值最高的物品，直到背包装满

代码实现

def fractional_knapsack(weights, values, capacity):
    n = len(weights)
    # 计算单位价值并排序
    items = [(values[i] / weights[i], weights[i], values[i], i) 
             for i in range(n)]
    items.sort(reverse=True, key=lambda x: x[0])
    
    total_value = 0
    selected = [0] * n  # 记录每个物品选择的比例
    
    for unit_val, weight, val, idx in items:
        if capacity >= weight:
            # 整个物品可以放下
            selected[idx] = 1
            total_value += val
            capacity -= weight
        else:
            # 只能放下部分
            fraction = capacity / weight
            selected[idx] = fraction
            total_value += fraction * val
            break  # 背包已满
    
    return total_value, selected

# 示例使用
weights = [2, 3, 4, 5]  # 物品重量
values = [3, 4, 5, 6]   # 物品价值
capacity = 8             # 背包容量

max_value, fractions = fractional_knapsack(weights, values, capacity)
print(f"最大价值: {max_value:.2f}")
print("物品选择比例:")
for i, frac in enumerate(fractions):
    print(f"物品{i}: {frac*100:.1f}%")

执行结果

最大价值: 12.67
物品选择比例:
物品0: 100.0%
物品1: 100.0%
物品2: 100.0%
物品3: 40.0%

2.3 贪心算法适用场景

• 活动选择问题：选择最多数量的互斥活动
• 霍夫曼编码：构造最优前缀码的数据压缩算法
• 最小生成树：Prim和Kruskal算法
• 最短路径：Dijkstra算法

三、动态规划 vs 贪心算法：关键差异

特性	动态规划	贪心算法
求解方式	自底向上或自顶向下	自顶向下
解空间	遍历所有可能解	仅考虑当前最优路径
时间复杂度	通常较高(O(n²), O(nW))	通常较低(O(n log n))
准确性	总能得到最优解	仅适用于特定问题
存储要求	需要存储子问题解	通常不需要额外存储
适用问题	具有最优子结构的问题	具有贪心选择性质的问题
经典案例	0-1背包、最长公共子序列	分数背包、最小生成树

3.1 选择策略：何时使用哪种算法？

1. 使用动态规划当：

   • 问题具有重叠子问题
   • 需要精确最优解
   • 问题结构允许分解为子问题
   • 贪心选择性质不成立（如0-1背包）

2. 使用贪心算法当：

   • 问题具有贪心选择性质
   • 需要高效解决方案
   • 贪心策略能保证全局最优
   • 问题可分解为一系列选择

四、综合应用：硬币找零问题

通过硬币找零问题展示两种算法的不同解决思路：

问题描述

给定不同面额的硬币和一个总金额，计算凑成总金额所需的最少硬币数量

4.1 动态规划解法

def coin_change_dp(coins, amount):
    # dp[i]表示组成金额i所需的最少硬币数
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0  # 金额0需要0个硬币
    
    for coin in coins:
        for x in range(coin, amount + 1):
            dp[x] = min(dp[x], dp[x - coin] + 1)
    
    return dp[amount] if dp[amount] != float('inf') else -1

# 示例
coins = [1, 2, 5]
amount = 11
print(f"DP最少硬币数: {coin_change_dp(coins, amount)}")  # 输出3 (5+5+1)

4.2 贪心算法解法（仅适用于特定面额）

def coin_change_greedy(coins, amount):
    coins.sort(reverse=True)  # 从大到小排序
    count = 0
    remaining = amount
    
    for coin in coins:
        # 尽可能多地使用当前面额
        if remaining == 0:
            break
        if coin <= remaining:
            num = remaining // coin
            count += num
            remaining -= num * coin
    
    return count if remaining == 0 else -1

# 示例（注意：贪心解法不总是最优！）
coins = [1, 2, 5]
amount = 11
print(f"贪心最少硬币数: {coin_change_greedy(coins, amount)}")  # 输出3

# 贪心失败的案例
coins = [1, 3, 4]
amount = 6
print(f"贪心结果: {coin_change_greedy(coins, amount)}")  # 输出3 (4+1+1)
print(f"DP结果: {coin_change_dp(coins, amount)}")        # 输出2 (3+3)

五、总结与进阶学习

动态规划和贪心算法是算法设计中的核心范式，理解它们的差异和适用场景对于解决复杂问题至关重要：

1. 动态规划 适合解决具有重叠子问题 和最优子结构的问题，通过存储中间结果提高效率
2. 贪心算法 在满足贪心选择性质的问题中更高效，但不保证全局最优
3. 实际问题中常需要结合其他技术（如剪枝、启发式方法）提高效率
4. 许多问题可以有多种解法，通过比较不同解法深化对算法本质的理解

进阶学习方向：

• 动态规划：状态压缩技巧、树形DP、数位DP
• 贪心算法：拟阵理论、贪心算法的正确性证明
• 混合方法：动态规划与贪心思想的结合应用

算法选择的智慧在于理解问题本质而非生搬硬套。通过持续练习和思考，你将培养出对算法选择的敏锐直觉，在解决复杂问题时游刃有余。

附录：常用算法问题分类

算法类型	经典问题
动态规划	最长公共子序列、编辑距离、矩阵链乘法
贪心算法	活动选择、霍夫曼编码、最小生成树
两者皆适用	部分背包问题、任务调度、最短路径问题