投研帮1. 动态规划（DP）基础概念解析
动态规划（Dynamic Programming，简称DP）是算法设计中的一种重要方法，特别适用于解决具有重叠子问题和最优子结构性质的问题。我第一次接触这个概念是在解决斐波那契数列问题时，发现简单的递归方法存在大量重复计算，而DP能显著提升效率。
1.1 DP的核心思想
DP本质上是一种"聪明"的递归，它通过存储子问题的解来避免重复计算。想象你在爬楼梯，每次可以迈1阶或2阶，问到第n阶有多少种走法。这个问题可以分解为：到第n阶的走法数=到第n-1阶的走法数+到第n-2阶的走法数。这就是DP的典型特征——问题可以分解为相似的子问题。
DP通常适用于两类问题：
- 计数问题：如"有多少种方式..."
- 优化问题：如"最小/最大值是多少..."
1.2 DP的三大特征
判断一个问题是否适合用DP解决，主要看是否具备以下特征：
- 最优子结构：问题的最优解包含子问题的最优解
- 重叠子问题：递归算法会反复求解相同的子问题
- 无后效性：当前状态一旦确定，后续决策不受之前决策影响
以经典的背包问题为例：给定物品的重量和价值，在背包容量限制下求最大价值。这个问题的解依赖于子问题的解（选择/不选择当前物品后的剩余容量），且这些子问题会被反复计算。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. DP问题分类与解题框架
2.1 DP问题的常见类型
根据状态转移方式的不同，DP问题可以分为几大类：
- 线性DP：最长递增子序列(LIS)、最大子数组和等
- 区间DP：矩阵链乘法、石子合并等
- 树形DP：树上的最大独立集等
- 状态压缩DP：旅行商问题(TSP)等
- 数位DP：统计数字中满足特定条件的数等
2.2 DP解题四步法
经过多年实践，我总结出解决DP问题的通用框架：
-
定义状态：明确dp数组的含义
- 例如：dp[i]表示前i个元素的最优解
- 二维情况：dp[i][j]表示在i,j条件下的解
-
确定状态转移方程
- 找出dp[i]与之前状态的关系
- 例如：dp[i] = max(dp[i-1], dp[i-2] + nums[i])
-
初始化边界条件
- 处理初始值，如dp[0]、dp[1]等
- 避免数组越界等错误
-
确定计算顺序
- 自顶向下（记忆化递归）
- 自底向上（迭代填表）
提示：初学者建议从自底向上的迭代方法开始，更容易理解和调试。
2.3 DP模板代码示例
以斐波那契数列为例，展示两种实现方式：
python复制# 方法1：递归+记忆化（自顶向下）
def fib(n, memo={}):
if n in memo: return memo[n]
if n <= 2: return 1
memo[n] = fib(n-1) + fib(n-2)
return memo[n]
# 方法2：迭代（自底向上）
def fib(n):
if n <= 2: return 1
dp = [0]*(n+1)
dp[1] = dp[2] = 1
for i in range(3, n+1):
dp[i] = dp[i-1] + dp[i-2]
return dp[n]
3. 经典DP问题详解
3.1 背包问题系列
背包问题是DP的经典应用，主要分为：
-
0-1背包：每种物品只能选或不选
- 状态定义：dp[i][j]表示前i件物品放入容量j的背包的最大价值
- 转移方程：dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])
-
完全背包：每种物品可以选无限次
- 转移方程变为：dp[i][j] = max(dp[i-1][j], dp[i][j-w[i]] + v[i])
-
多重背包：每种物品有数量限制
python复制# 0-1背包Python实现
def knapsack(W, wt, val, n):
dp = [[0]*(W+1) for _ in range(n+1)]
for i in range(1, n+1):
for w in range(1, W+1):
if wt[i-1] <= w:
dp[i][w] = max(val[i-1] + dp[i-1][w-wt[i-1]], dp[i-1][w])
else:
dp[i][w] = dp[i-1][w]
return dp[n][W]
3.2 最长公共子序列(LCS)
LCS是字符串处理中的经典DP问题：
- 状态定义：dp[i][j]表示X前i个和Y前j个字符的LCS长度
- 转移方程：
- 如果X[i]==Y[j]: dp[i][j] = dp[i-1][j-1] + 1
- 否则: dp[i][j] = max(dp[i-1][j], dp[i][j-1])
3.3 股票买卖问题
这个系列问题有多种变体，以最简单的"一次交易"为例：
- 状态定义：
- dp[i][0]：第i天不持有股票的最大利润
- dp[i][1]：第i天持有股票的最大利润
- 转移方程：
- dp[i][0] = max(dp[i-1][0], dp[i-1][1] + prices[i])
- dp[i][1] = max(dp[i-1][1], -prices[i])
4. DP优化技巧
4.1 空间优化
很多DP问题可以优化空间复杂度，如斐波那契数列只需保存前两个状态：
python复制def fib(n):
if n <= 2: return 1
prev, curr = 1, 1
for _ in range(3, n+1):
prev, curr = curr, prev + curr
return curr
背包问题也可以从二维数组优化为一维数组，但需要注意遍历顺序：
python复制# 0-1背包空间优化版
def knapsack(W, wt, val, n):
dp = [0]*(W+1)
for i in range(n):
for w in range(W, wt[i]-1, -1): # 反向遍历
dp[w] = max(dp[w], dp[w-wt[i]] + val[i])
return dp[W]
4.2 状态压缩
对于状态较少的DP（如状态压缩DP），可以用位运算表示状态：
python复制# 旅行商问题(TSP)状态压缩示例
def tsp(dist):
n = len(dist)
dp = [[float('inf')]*n for _ in range(1<<n)]
dp[1][0] = 0 # 从城市0出发
for mask in range(1<<n):
for u in range(n):
if not (mask & (1<<u)): continue
for v in range(n):
if mask & (1<<v): continue
dp[mask|(1<<v)][v] = min(dp[mask|(1<<v)][v], dp[mask][u]+dist[u][v])
return min(dp[(1<<n)-1][u] + dist[u][0] for u in range(n))
4.3 记忆化搜索
对于不方便确定计算顺序的问题，可以采用记忆化递归：
python复制# 记忆化搜索示例：最长递增子序列
def lengthOfLIS(nums):
memo = {}
def dp(i):
if i in memo: return memo[i]
max_len = 1
for j in range(i):
if nums[j] < nums[i]:
max_len = max(max_len, dp(j) + 1)
memo[i] = max_len
return max_len
return max(dp(i) for i in range(len(nums)))
5. DP实战技巧与常见错误
5.1 调试DP问题的技巧
- 打印DP表：对于二维DP，打印中间结果有助于发现问题
- 小规模测试：先用简单例子验证正确性
- 边界检查：特别注意i=0,j=0等边界条件
- 状态追踪：记录决策路径，便于理解状态转移
5.2 常见错误及解决方法
- 数组越界：确保访问dp[i-1]时i>0
- 初始化错误：仔细检查初始条件设置
- 顺序错误：确保计算dp[i]时所需的状态已计算
- 状态定义不当：有时需要增加状态维度
5.3 DP问题选择策略
- 从简单问题入手：如斐波那契、爬楼梯
- 理解经典问题：背包、LCS、编辑距离等
- 识别问题模式：看到"最值"、"多少种方式"等关键词考虑DP
- 练习变种问题：如带约束条件的DP
6. 进阶DP问题解析
6.1 数位DP
数位DP用于解决与数字各位相关的计数问题，如"统计1到n中包含特定数字的数字个数"。
基本框架：
- 将数字转换为数位数组
- 设计状态：通常包括位置、是否受限、前导零等
- 记忆化搜索实现
python复制# 数位DP示例：统计1到n中数字'1'的出现次数
def countDigitOne(n):
s = str(n)
@lru_cache(maxsize=None)
def dp(pos, tight, count):
if pos == len(s):
return count
limit = int(s[pos]) if tight else 9
total = 0
for d in range(0, limit+1):
new_tight = tight and (d == limit)
new_count = count + (1 if d == 1 else 0)
total += dp(pos+1, new_tight, new_count)
return total
return dp(0, True, 0)
6.2 树形DP
树形DP在树结构上进行状态转移，典型问题是树上的最大独立集。
解题步骤：
- 后序遍历树结构
- 对每个节点定义状态（如选/不选）
- 合并子树信息
python复制# 树形DP示例：二叉树的最大独立集
class TreeNode:
def __init__(self, val=0, left=None, right=None):
self.val = val
self.left = left
self.right = right
def rob(root):
def dfs(node):
if not node:
return (0, 0) # (选当前, 不选当前)
left = dfs(node.left)
right = dfs(node.right)
# 选当前节点，则不能选子节点
rob = node.val + left[1] + right[1]
# 不选当前节点，子节点可选可不选
not_rob = max(left) + max(right)
return (rob, not_rob)
return max(dfs(root))
6.3 区间DP
区间DP处理涉及区间的问题，如矩阵链乘法、回文分割等。
典型特征：
- 状态定义为dp[i][j]，表示区间i到j的解
- 通常需要枚举分割点k
python复制# 区间DP示例：最长回文子序列
def longestPalindromeSubseq(s):
n = len(s)
dp = [[0]*n for _ in range(n)]
for i in range(n-1, -1, -1):
dp[i][i] = 1
for j in range(i+1, n):
if s[i] == s[j]:
dp[i][j] = dp[i+1][j-1] + 2
else:
dp[i][j] = max(dp[i+1][j], dp[i][j-1])
return dp[0][n-1]
7. DP与其他算法的结合
7.1 DP与贪心算法
有些问题可以用贪心算法优化DP，如跳跃游戏问题：
python复制# 跳跃游戏II：最少跳跃次数
def jump(nums):
jumps = 0
current_end = 0
farthest = 0
for i in range(len(nums)-1):
farthest = max(farthest, i + nums[i])
if i == current_end:
jumps += 1
current_end = farthest
return jumps
7.2 DP与分治
矩阵链乘法是DP与分治结合的典型例子：
python复制# 矩阵链乘法最小计算代价
def matrixChainOrder(p):
n = len(p)-1
dp = [[0]*n for _ in range(n)]
for l in range(2, n+1): # 链长度
for i in range(n-l+1):
j = i + l - 1
dp[i][j] = float('inf')
for k in range(i, j):
cost = dp[i][k] + dp[k+1][j] + p[i]*p[k+1]*p[j+1]
if cost < dp[i][j]:
dp[i][j] = cost
return dp[0][n-1]
7.3 DP与图论
最短路径问题中的Floyd-Warshall算法就是DP的应用：
python复制# Floyd-Warshall算法
def floydWarshall(graph):
V = len(graph)
dist = [row[:] for row in graph]
for k in range(V):
for i in range(V):
for j in range(V):
if dist[i][j] > dist[i][k] + dist[k][j]:
dist[i][j] = dist[i][k] + dist[k][j]
return dist
8. DP在实际工程中的应用
8.1 文本差异比较
Diff工具、版本控制系统中的文本比较基于编辑距离DP算法：
python复制# 编辑距离
def minDistance(word1, word2):
m, n = len(word1), len(word2)
dp = [[0]*(n+1) for _ in range(m+1)]
for i in range(m+1):
dp[i][0] = i
for j in range(n+1):
dp[0][j] = j
for i in range(1, m+1):
for j in range(1, n+1):
if word1[i-1] == word2[j-1]:
dp[i][j] = dp[i-1][j-1]
else:
dp[i][j] = 1 + min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1])
return dp[m][n]
8.2 资源调度
任务调度、CPU资源分配等问题常使用DP求解：
python复制# 任务调度最大收益
def jobScheduling(startTime, endTime, profit):
jobs = sorted(zip(startTime, endTime, profit), key=lambda x: x[1])
dp = [[0, 0]] # [end_time, total_profit]
for s, e, p in jobs:
# 二分查找最后一个结束时间<=s的工作
i = bisect.bisect_right(dp, [s, float('inf')]) - 1
if dp[i][1] + p > dp[-1][1]:
dp.append([e, dp[i][1] + p])
return dp[-1][1]
8.3 游戏AI
许多游戏AI的决策系统使用DP计算最优策略：
python复制# 硬币游戏：玩家轮流取硬币，最大化自己所得
def maxCoin(coins):
n = len(coins)
dp = [[0]*n for _ in range(n)]
for i in range(n-1, -1, -1):
for j in range(i, n):
if i == j:
dp[i][j] = coins[i]
else:
dp[i][j] = max(coins[i] - dp[i+1][j], coins[j] - dp[i][j-1])
return dp[0][n-1]
9. DP学习资源与训练建议
9.1 推荐学习路径
-
基础阶段：
- 斐波那契数列
- 爬楼梯问题
- 最小路径和
- 背包问题
-
进阶阶段：
- 股票买卖系列
- 字符串DP（LCS、编辑距离）
- 区间DP（矩阵链乘法）
- 树形DP
-
高级阶段：
- 状态压缩DP
- 数位DP
- 概率DP
- 动态DP（支持动态修改）
9.2 在线练习平台
- LeetCode：按DP标签筛选题目
- Codeforces：Div2/Div3的DP问题
- AtCoder：Educational DP Contest
- 洛谷：专门的DP训练集
9.3 经典教材与参考
- 《算法导论》第15章：动态规划
- 《算法竞赛入门经典》第9章：动态规划初步
- 《挑战程序设计竞赛》第3章：动态规划
- 《计算机程序设计艺术》相关章节
10. DP问题实战心得
在实际解决DP问题时，我总结了几个关键心得：
- 先想暴力递归，再优化为DP：这有助于理解问题本质
- 状态定义决定难度：好的状态定义能让问题简单很多
- 从特殊到一般：先解决小规模问题，再推广
- 多画DP表：可视化有助于理解状态转移
- 注意空间优化：很多问题可以降维
对于初学者，建议从最简单的爬楼梯问题开始，逐步增加难度。遇到困难时，可以：
- 参考经典问题的解法
- 在纸上手动模拟DP过程
- 与他人讨论思路
- 查看高质量题解
最后记住，DP是一种需要大量练习才能掌握的技能。我在最初学习时，曾花了两周时间专门练习各种背包问题变种，才真正理解了状态设计的技巧。