动态规划：从斐波那契数列到路径问题

发布时间：2026/10/29 15:31:20
动态规划：从斐波那契数列到路径问题

1. 斐波那契数列与路径问题的奇妙关联

第一次接触动态规划时，我就被斐波那契数列这个经典案例深深吸引。记得当时为了理解递归解法的时间复杂度，我在白板上画满了重复计算的子问题，那种"顿悟"的感觉至今难忘。后来当学到不同路径问题时，惊讶地发现它本质上就是斐波那契问题的二维变体。

斐波那契数列的定义简单优雅：F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)。这个看似简单的数列却蕴含着动态规划的核心思想——重叠子问题和最优子结构。当我们用递归实现时，时间复杂度高达O(2^n)，而改用动态规划后可以优化到O(n)。

不同路径问题则是这样一个场景：在m×n的网格中，机器人从左上角出发，每次只能向右或向下移动一步，问到达右下角有多少种不同的路径。这个问题的递推关系与斐波那契数列惊人地相似：dp[i][j] = dp[i-1][j] + dp[i][j-1]。

2. 从递归到动态规划的思维转变

2.1 斐波那契数列的递归解法陷阱

让我们先用最直观的递归方法实现斐波那契数列：

def fib(n): if n <= 1: return n return fib(n-1) + fib(n-2)

这个实现虽然简洁，但存在严重的性能问题。以计算fib(5)为例，调用树如下：

fib(5) ├── fib(4) │ ├── fib(3) │ │ ├── fib(2) │ │ │ ├── fib(1) │ │ │ └── fib(0) │ │ └── fib(1) │ └── fib(2) │ ├── fib(1) │ └── fib(0) └── fib(3) ├── fib(2) │ ├── fib(1) │ └── fib(0) └── fib(1)

可以看到fib(3)被计算了2次，fib(2)被计算了3次。随着n增大，重复计算呈指数级增长。

2.2 动态规划的优化思路

动态规划通过存储中间结果来避免重复计算。斐波那契数列的DP解法有两种主要实现方式：

自顶向下带备忘录的递归（记忆化搜索）：

def fib_memo(n, memo={}): if n <= 1: return n if n not in memo: memo[n] = fib_memo(n-1, memo) + fib_memo(n-2, memo) return memo[n]

自底向上的迭代法：

def fib_dp(n): if n <= 1: return 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]

这两种方法都将时间复杂度降到了O(n)，空间复杂度也是O(n)。进一步优化空间复杂度到O(1)：

def fib_optimized(n): if n <= 1: return n a, b = 0, 1 for _ in range(2, n+1): a, b = b, a + b return b

3. 不同路径问题的动态规划解法

3.1 问题描述与初步分析

不同路径问题的正式描述是：在一个m×n的网格中，机器人从左上角(0,0)出发，每次只能向右或向下移动一步，到达右下角(m-1,n-1)有多少种不同的路径？

这个问题可以看作是斐波那契数列的二维扩展。在网格中，到达某个格子的路径数等于从上方格子来的路径数加上从左方格子来的路径数，这与斐波那契的递推关系非常相似。

3.2 基础DP解法实现

def uniquePaths(m, n): dp = [[1] * n for _ in range(m)] for i in range(1, m): for j in range(1, n): dp[i][j] = dp[i-1][j] + dp[i][j-1] return dp[m-1][n-1]

这个解法的时间复杂度是O(m×n)，空间复杂度也是O(m×n)。我们可以观察到，实际上只需要保存前一行的数据即可，因此可以优化空间复杂度：

def uniquePaths_optimized(m, n): dp = [1] * n for _ in range(1, m): for j in range(1, n): dp[j] += dp[j-1] return dp[-1]

3.3 数学组合数解法

不同路径问题还可以用组合数学的方法解决。机器人需要移动m-1次向下，n-1次向右，总共m+n-2次移动。因此路径总数为C(m+n-2, m-1)或C(m+n-2, n-1)。

import math def uniquePaths_math(m, n): return math.comb(m + n - 2, m - 1)

这种方法的时间复杂度是O(min(m,n))，空间复杂度O(1)，但在m和n较大时需要注意数值溢出问题。

4. 进阶问题与变种探讨

4.1 带障碍物的不同路径问题

现在考虑网格中有障碍物的情况，用1表示障碍物，0表示可通过的空格。我们需要修改DP方程：

def uniquePathsWithObstacles(obstacleGrid): m, n = len(obstacleGrid), len(obstacleGrid[0]) dp = [[0] * n for _ in range(m)] # 初始化第一行和第一列 dp[0][0] = 1 if obstacleGrid[0][0] == 0 else 0 for i in range(1, m): dp[i][0] = dp[i-1][0] if obstacleGrid[i][0] == 0 else 0 for j in range(1, n): dp[0][j] = dp[0][j-1] if obstacleGrid[0][j] == 0 else 0 for i in range(1, m): for j in range(1, n): if obstacleGrid[i][j] == 0: dp[i][j] = dp[i-1][j] + dp[i][j-1] else: dp[i][j] = 0 return dp[m-1][n-1]

4.2 最小路径和问题

这是另一个常见变种，给定一个包含非负整数的m×n网格，找出一条从左上角到右下角的路径，使得路径上的数字总和最小。

def minPathSum(grid): m, n = len(grid), len(grid[0]) dp = [[0] * n for _ in range(m)] dp[0][0] = grid[0][0] # 初始化第一行和第一列 for i in range(1, m): dp[i][0] = dp[i-1][0] + grid[i][0] for j in range(1, n): dp[0][j] = dp[0][j-1] + grid[0][j] for i in range(1, m): for j in range(1, n): dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j] return dp[m-1][n-1]

4.3 三维路径问题

如果将问题扩展到三维空间，比如在一个立方体中从一角到对角线的另一角，每次只能沿x、y或z轴移动一步，那么解法也是类似的：

def uniquePaths3D(x, y, z): dp = [[[1] * z for _ in range(y)] for _ in range(x)] for i in range(1, x): for j in range(1, y): for k in range(1, z): dp[i][j][k] = dp[i-1][j][k] + dp[i][j-1][k] + dp[i][j][k-1] return dp[x-1][y-1][z-1]

5. 动态规划的通用解题框架

通过解决斐波那契数列和不同路径问题，我们可以总结出动态规划解题的一般步骤：

  1. 定义子问题：明确dp数组的含义，如fib(n)表示第n个斐波那契数，dp[i][j]表示到达(i,j)的路径数。

  2. 确定状态转移方程：找出子问题之间的关系，如fib(n)=fib(n-1)+fib(n-2)。

  3. 初始化边界条件：如fib(0)=0，fib(1)=1；路径问题中第一行和第一列通常初始化为1。

  4. 确定计算顺序：自底向上或自顶向下，确保在计算当前状态时所需的前驱状态已经计算过。

  5. 考虑空间优化：观察是否可以压缩状态数组，如斐波那契数列只需要保存前两个状态。

  6. 处理边界情况：如网格中有障碍物、负数等情况需要特殊处理。

6. 实际应用中的注意事项

6.1 数值溢出问题

在计算大数的斐波那契数或路径数时，可能会遇到数值溢出。解决方法包括：

  • 使用大整数类型（如Python的int自动支持大数）
  • 取模运算（如结果对某个大质数取模）
  • 使用字符串或数组表示大数

6.2 空间优化技巧

对于二维DP问题，常用的空间优化方法有：

  1. 滚动数组：只保存必要的几行数据（通常是两行）
  2. 原地修改：直接在输入数组上修改（如果允许）
  3. 对角线遍历：按对角线顺序计算，只需保存前一条对角线的数据

6.3 调试与验证

动态规划代码容易出错的地方包括：

  • 边界条件初始化不正确
  • 状态转移方程写错
  • 数组索引越界
  • 空间优化后更新顺序错误

建议的调试方法：

  1. 打印DP表格，检查中间结果
  2. 先用小规模测试用例验证
  3. 对比递归解法和DP解法的结果
  4. 考虑极端情况（如m=1或n=1）

7. 性能对比与算法选择

让我们比较不同解法在LeetCode上的表现（以不同路径问题为例）：

方法时间复杂度空间复杂度适用场景
基础DPO(mn)O(mn)通用解法
优化DPO(mn)O(n)空间敏感
组合数学O(min(m,n))O(1)无障碍物
记忆化递归O(mn)O(mn)自上而下思维

在实际面试中，建议先给出基础DP解法，然后讨论优化空间的可能性，最后如果时间允许可以提到数学解法，展示全面的思考过程。

8. 从斐波那契到路径问题的思维延伸

理解斐波那契数列和路径问题之间的关系，有助于我们识别更多类似的DP问题模式：

  1. 爬楼梯问题：每次可以爬1或2阶，到第n阶有多少种方法？这其实就是斐波那契数列。
  2. 解码方法：数字串解码成字母，考虑最后1位或2位的解码方式。
  3. 买卖股票问题：某些限制条件下的最大利润计算。
  4. 抢劫房屋问题：不能抢劫相邻房屋的最大收益。

这些问题的共同特点是当前状态依赖于有限个前驱状态，可以通过类似的DP框架解决。

9. C++实现示例

最后给出不同路径问题的C++实现，这也是网络热词中提到的需求：

#include <vector> using namespace std; int uniquePaths(int m, int n) { vector<vector<int>> dp(m, vector<int>(n, 1)); for (int i = 1; i < m; ++i) { for (int j = 1; j < n; ++j) { dp[i][j] = dp[i-1][j] + dp[i][j-1]; } } return dp[m-1][n-1]; } // 空间优化版本 int uniquePaths_optimized(int m, int n) { vector<int> dp(n, 1); for (int i = 1; i < m; ++i) { for (int j = 1; j < n; ++j) { dp[j] += dp[j-1]; } } return dp[n-1]; }

对于最长不下降序列问题（另一个网络热词），C++实现如下：

#include <vector> #include <algorithm> using namespace std; pair<int, vector<int>> lengthOfLIS(vector<int>& nums) { if (nums.empty()) return {0, {}}; int n = nums.size(); vector<int> dp(n, 1); // dp[i]表示以nums[i]结尾的LIS长度 vector<int> prev(n, -1); // 记录前驱节点 for (int i = 1; i < n; ++i) { for (int j = 0; j < i; ++j) { if (nums[j] <= nums[i] && dp[j] + 1 > dp[i]) { dp[i] = dp[j] + 1; prev[i] = j; } } } int max_len = *max_element(dp.begin(), dp.end()); int pos = distance(dp.begin(), find(dp.begin(), dp.end(), max_len)); // 重构序列 vector<int> sequence; while (pos != -1) { sequence.push_back(nums[pos]); pos = prev[pos]; } reverse(sequence.begin(), sequence.end()); return {max_len, sequence}; }

这个实现不仅返回最长不下降序列的长度，还返回序列本身。算法时间复杂度为O(n²)，空间复杂度O(n)。对于更大规模的数据，可以使用O(nlogn)的优化算法。