当前位置：首页 > news >正文

深入理解动态规划：从斐波那契数列到最优子结构

news 2025/7/8 18:25:18

引言

动态规划(Dynamic Programming, DP)是算法设计中一种非常重要的思想，广泛应用于解决各类优化问题。许多看似复杂的问题，通过动态规划的视角分析，往往能找到高效的解决方案。本文将系统介绍动态规划的核心概念，通过经典案例展示其应用，并探讨如何识别和解决动态规划问题。

一、什么是动态规划？

动态规划是一种分治思想的延伸，主要用于解决具有重叠子问题和最优子结构性质的问题。与普通的分治算法不同，动态规划会保存已解决的子问题的答案，避免重复计算，从而显著提高效率。

动态规划通常用于两类问题：

优化问题：寻找问题的最优解（最大或最小值）
组合问题：计算满足特定条件的解的数量

2. 动态规划的核心思想

动态规划适用于具有以下两个关键性质的问题：

重叠子问题（Overlapping Subproblems） ：问题可以分解为若干子问题，且子问题之间存在重复计算。
最优子结构（Optimal Substructure） ：问题的最优解可以由子问题的最优解推导而来。

动态规划通常有两种实现方式：

自顶向下（Top-Down） ：递归 + 记忆化（Memoization）
自底向上（Bottom-Up） ：迭代 + DP 表

3. 从斐波那契数列理解动态规划

3.1 递归解法的问题

斐波那契数列定义：

F(0)=0F(0)=0
F(1)=1F(1)=1
F(n)=F(n−1)+F(n−2)F(n)=F(n−1)+F(n−2) （n≥2n≥2）

递归实现（C++） ：

int fib(int n) {if (n <= 1) return n;return fib(n - 1) + fib(n - 2);
}

问题：时间复杂度 O(2n)，存在大量重复计算（如 fib(3) 被多次计算）。

3.2 记忆化递归（Top-Down DP）

使用数组或哈希表存储已计算的结果：

int fibMemo(int n, vector<int>& memo) {if (n <= 1) return n;if (memo[n] != -1) return memo[n];memo[n] = fibMemo(n - 1, memo) + fibMemo(n - 2, memo);return memo[n];
}int fib(int n) {vector<int> memo(n + 1, -1);return fibMemo(n, memo);
}

优化后时间复杂度：O(n)，空间复杂度 O(n)。

3.3 自底向上 DP（Bottom-Up DP）

用迭代方式计算：

int fib(int n) {if (n <= 1) return n;vector<int> dp(n + 1);dp[0] = 0;dp[1] = 1;for (int i = 2; i <= n; i++) {dp[i] = dp[i - 1] + dp[i - 2];}return dp[n];
}

进一步优化空间（仅保留前两个状态）：

int fib(int n) {if (n <= 1) return n;int a = 0, b = 1;for (int i = 2; i <= n; i++) {int c = a + b;a = b;b = c;}return b;
}

时间复杂度：O(n)，空间复杂度：O(1)。

4. 最优子结构与状态转移方程

动态规划的关键在于：

定义状态（如 dp[i] 表示第 i 个问题的解）。
找到状态转移方程（递推关系）。
初始化边界条件（如 dp[0] 和 dp[1]）。

例题 1：爬楼梯（LeetCode 70）

题目链接

问题：每次可以爬 1 或 2 阶台阶，求爬到第 n 阶的方法数。
状态定义：dp[i] 表示爬到第 i 阶的方法数。
状态转移方程：

dp[i]=dp[i−1]+dp[i−2]dp[i]=dp[i−1]+dp[i−2]
C++ 实现：

int climbStairs(int n) {if (n <= 2) return n;int a = 1, b = 2;for (int i = 3; i <= n; i++) {int c = a + b;a = b;b = c;}return b;
}

例题 2：最大子数组和（LeetCode 53）

题目链接

问题：给定整数数组 nums，求连续子数组的最大和。
状态定义：dp[i] 表示以 nums[i] 结尾的最大子数组和。
状态转移方程：

dp[i]=max⁡(dp[i−1]+nums[i],nums[i])dp[i]=max(dp[i−1]+nums[i],nums[i])
C++ 实现：

int maxSubArray(vector<int>& nums) {int maxSum = nums[0], currSum = nums[0];for (int i = 1; i < nums.size(); i++) {currSum = max(currSum + nums[i], nums[i]);maxSum = max(maxSum, currSum);}return maxSum;
}

例题 3：最长递增子序列（LeetCode 300）

题目链接

问题：求数组中最长的严格递增子序列长度。
状态定义：dp[i] 表示以 nums[i] 结尾的最长递增子序列长度。
状态转移方程：

dp[i]=max⁡(dp[j]+1)其中0≤j<i且nums[j]<nums[i]dp[i]=max(dp[j]+1)其中0≤j<i且nums[j]<nums[i]
C++ 实现：

int lengthOfLIS(vector<int>& nums) {int n = nums.size();vector<int> dp(n, 1);int maxLen = 1;for (int i = 1; i < n; i++) {for (int j = 0; j < i; j++) {if (nums[j] < nums[i]) {dp[i] = max(dp[i], dp[j] + 1);}}maxLen = max(maxLen, dp[i]);}return maxLen;
}