动态规划入门：核心三要素与竞赛实战技巧

最新推荐文章于 2026-11-02 13:08:45 发布

原创最新推荐文章于 2026-11-02 13:08:45 发布 · 260 阅读

本内容遵循CC 4.0 BY-SA版权协议

本文系统讲解动态规划（DP）的三大核心要素：最优子结构、重叠子问题和状态转移方程，并结合硬币找零、最长上升子序列（LIS）、01背包等经典问题展开自底向上与记忆化搜索两种实现方式。深入剖析CSP-J/S竞赛真题，涵盖状态压缩、区间DP、树形DP等进阶技巧，同时指出新手常见误区及调试方法，提供分阶段训练路径与主流评测平台推荐。

1. 动态规划入门：从直觉到理论的思维跃迁

作为一名带过上百名信奥选手的教练，我发现动态规划（DP）是CSP-J/S竞赛中最让初学者头疼的知识点。很多学生能理解递归和递推，却在面对DP问题时无从下手。这篇文章将用最接地气的方式，带你完成从直觉认知到理论建模的关键跨越。

动态规划本质上是一种"聪明地穷举"方法。举个生活中的例子：假设你要从1楼爬到10楼，每次可以跨1级或2级台阶。问有多少种走法？如果直接用递归思维，会重复计算大量子问题（比如爬到第5楼的所有走法）。而DP的做法是建立一张表格，从底层开始记录每层楼的走法数，这就是典型的"记忆化搜索"思想。

2. 动态规划核心三要素解析

2.1 最优子结构：多米诺骨牌效应

最优子结构意味着大问题的最优解包含子问题的最优解。就像多米诺骨牌，只要保证每块牌都能推倒下一块，最终所有牌都会倒下。在台阶问题中，到达第n阶的方案数f(n) = f(n-1) + f(n-2)，这就是典型的最优子结构。

关键检验方法：如果问题的最优解需要用到子问题的最优解，而不是子问题的全部解，就具备最优子结构。

2.2 重叠子问题：避免重复劳动的智慧

对比普通递归与DP求解斐波那契数列的时间复杂度：

递归：O(2^n) （存在大量重复计算）
DP：O(n) （每个子问题只计算一次）

# 递归解法
def fib(n):
    if n <= 1: return n
    return fib(n-1) + fib(n-2)

# DP解法
def fib_dp(n):
    dp = [0]*(n+1)
    dp[1] = 1
    for i in range(2, n+1):
        dp[i] = dp[i-1] + dp[i-2]
    return dp[n]

2.3 状态转移方程：DP的灵魂公式

建立状态转移方程的三步法：

定义状态：dp[i]代表什么？
确定边界：初始条件是什么？
建立关系：如何用已知状态推导新状态？

以经典的01背包问题为例：

状态定义：dp[i][j]表示前i件物品放入容量j的背包的最大价值
边界条件：dp[0][j]=0, dp[i][0]=0

状态转移：

dp[i][j] = \begin{cases} 
dp[i-1][j], & \text{不放第i件物品} \\
dp[i-1][j-w_i] + v_i, & \text{放入第i件物品}
\end{cases}

3. 典型问题实战训练

3.1 硬币找零问题（自底向上解法）

问题描述：给定不同面额的硬币coins和总金额amount，计算凑成总金额所需的最少硬币数。

def coinChange(coins, amount):
    dp = [float('inf')] * (amount + 1)
    dp[0] = 0
    for coin in coins:
        for i in range(coin, amount+1):
            dp[i] = min(dp[i], dp[i-coin]+1)
    return dp[amount] if dp[amount] != float('inf') else -1

关键点说明：

dp数组初始化为无穷大（表示不可达）
金额0需要0个硬币（边界条件）
双重循环顺序不能交换（先遍历硬币还是先遍历金额？思考为什么）

3.2 最长上升子序列（LIS）的两种视角

解法一：常规DP（O(n²)）

def lengthOfLIS(nums):
    dp = [1]*len(nums)
    for i in range(1, len(nums)):
        for j in range(i):
            if nums[j] < nums[i]:
                dp[i] = max(dp[i], dp[j]+1)
    return max(dp)

解法二：贪心+二分（O(nlogn)）

import bisect
def lengthOfLIS(nums):
    tails = []
    for num in nums:
        idx = bisect.bisect_left(tails, num)
        if idx == len(tails):
            tails.append(num)
        else:
            tails[idx] = num
    return len(tails)

两种解法的对比：

维度	常规DP	贪心+二分
时间复杂度	O(n²)	O(nlogn)
空间复杂度	O(n)	O(n)
适用场景	通用	仅求长度
代码复杂度	简单	较复杂

4. 竞赛中的DP技巧精要

4.1 状态压缩：降维打击的艺术

当DP状态中存在可以压缩的维度时，能大幅降低空间复杂度。以01背包为例：

# 原始二维DP
dp = [[0]*(W+1) for _ in range(n+1)]

# 优化为一维DP
dp = [0]*(W+1)
for i in range(n):
    for j in range(W, weight[i]-1, -1):  # 注意逆序
        dp[j] = max(dp[j], dp[j-weight[i]] + value[i])

为什么内层要逆序遍历？试想如果正序遍历，前面的修改会影响后面的计算结果，而逆序可以避免这个问题。

4.2 记忆化搜索：自顶向下的思考方式

有些问题用递归思路更直观，这时可以用记忆化搜索（Memoization）：

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

记忆化搜索的特点：

代码更接近自然思维
避免了手动处理计算顺序
适合状态转移复杂的场景
会有递归栈开销

4.3 常见DP类型速查表

问题类型	典型例题	状态定义要点
线性DP	最大子序和	dp[i]表示以i结尾的解
区间DP	石子合并	dp[i][j]表示区间i-j
树形DP	二叉树最大路径和	每个节点返回两个状态
状态机DP	买卖股票最佳时机	持有/不持有股票状态
数位DP	数字1的个数统计	前导零、是否受限处理

5. 新手常见误区与突破方法

5.1 识别DP问题的三大特征

不是所有问题都适合用DP解决，具备以下特征的问题才考虑DP：

问题可分解为相似子问题
子问题之间存在重叠
需要求解最优值或计数

反例：图的遍历（子问题不重叠）、素数判断（无最优子结构）

5.2 调试DP程序的实用技巧

打印DP表：这是最直接的调试方法

def print_dp_table(dp):
    for row in dp:
        print([f"{x:2d}" for x in row])

边界检查：特别注意初始条件的设置
状态追踪：记录每个状态的转移来源
小规模测试：先用简单案例验证

5.3 从看懂到写对的训练路径

我的教学经验表明，有效的训练顺序应该是：

理解经典问题（斐波那契、背包、LIS）
手动模拟DP表格填充过程
改写他人代码（改变状态定义方式）
尝试相似题目（如从硬币找零到纸币组合问题）
参加虚拟竞赛（如Codeforces Div2的A-C题）

特别提醒：不要直接看题解！先自己思考状态定义，哪怕错误也是宝贵的经验。

6. 竞赛真题剖析（CSP-J/S风格）

6.1 2022年CSP-J组真题选讲

题目：有n个物品排成一排，每个物品有价值v[i]。选择若干不相邻的物品，求最大总价值。

状态定义：

dp[i][0]：不选第i个物品时的最大价值
dp[i][1]：选择第i个物品时的最大价值

转移方程：

dp[i][0] = max(dp[i-1][0], dp[i-1][1])
dp[i][1] = dp[i-1][0] + v[i]

6.2 2021年CSP-S组DP题解析

题目：给定字符串s，求最长回文子序列长度。

解法：区间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]

关键点：