上篇文章我们提到“动态规划”通过解决重叠子问题和利用最优子结构，为许多复杂优化问题提供了有效的解决方案。然而，在实际应用中，随着问题规模的增大，动态规划算法可能面临时间和空间上的性能瓶颈。这次本文将深入探讨动态规划的优化技巧，结合 Java 和 Python 代码，帮助读者在实际开发中提升算法效率。
一、空间压缩：减少内存占用
在动态规划中，状态数组往往会占用大量内存。当状态转移仅依赖于前几个状态时，可以通过滚动数组或其他方式压缩空间，将空间复杂度从 (O(n)) 或 (O(n^2)) 降低至 (O(1)) 或 (O(k))（(k) 为固定常数）。
1.1 一维滚动数组
以斐波那契数列为例，其状态转移方程为 dp[n] = dp[n - 1] + dp[n - 2]，每个状态仅依赖前两个状态。因此，无需使用长度为 (n) 的数组存储所有中间结果，仅需三个变量即可完成计算。
Python 代码
def fibonacci_space_optimized(n):
if n <= 1:
return n
a, b = 0, 1
for _ in range(1, n):
a, b = b, a + b
return b
Java 代码
public class FibonacciSpaceOptimized {
public static int fibonacciSpaceOptimized(int n) {
if (n <= 1) {
return n;
}
int a = 0, b = 1;
for (int i = 1; i < n; i++) {
int temp = b;
b = a + b;
a = temp;
}
return b;
}
}
通过上述代码，空间复杂度从原始的 (O(n)) 优化至 (O(1))，显著减少了内存开销。
1.2 二维滚动数组
对于二维动态规划问题，如 0-1 背包问题，其状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]) 表明，第 (i) 行的状态仅依赖于第 (i - 1) 行。此时，可以使用两个一维数组交替存储相邻两行的状态，实现空间压缩。
Python 代码
def knapsack_01_space_optimized(w, v, W):
n = len(w)
dp_prev = [0] * (W + 1)
dp_curr = [0] * (W + 1)
for i in range(1, n + 1):
for j in range(1, W + 1):
if w[i - 1] > j:
dp_curr[j] = dp_prev[j]
else:
dp_curr[j] = max(dp_prev[j], dp_prev[j - w[i - 1]] + v[i - 1])
dp_prev = dp_curr.copy()
return dp_curr[W]
Java 代码
public class Knapsack01SpaceOptimized {
public static int knapsack01SpaceOptimized(int[] w, int[] v, int W) {
int n = w.length;
int[] dp_prev = new int[W + 1];
int[] dp_curr = new int[W + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= W; j++) {
if (w[i - 1] > j) {
dp_curr[j] = dp_prev[j];
} else {
dp_curr[j] = Math.max(dp_prev[j], dp_prev[j - w[i - 1]] + v[i - 1]);
}
}
dp_prev = dp_curr.clone();
}
return dp_curr[W];
}
}
进一步优化，可直接使用一个一维数组，通过倒序遍历避免状态覆盖问题，将空间复杂度降至 (O(W))。
二、状态转移方程简化：减少计算量
复杂的状态转移方程可能包含冗余计算。通过分析问题特性，简化状态定义或转移逻辑，能够有效降低时间复杂度。
以最长公共子序列（LCS）问题为例，若已知序列长度存在一定限制，可通过预处理减少无效状态。假设序列 X 和 Y 中相同元素的分布具有规律性，可提前标记可能构成公共子序列的元素位置，避免对所有位置进行无意义的比较。
Python 代码（简化思路示例）
def preprocess_lcs(X, Y):
pos_dict = {}
for i, x in enumerate(X):
if x not in pos_dict:
pos_dict[x] = []
pos_dict[x].append(i)
return pos_dict
def lcs_simplified(X, Y):
pos_dict = preprocess_lcs(X, Y)
m, n = len(X), len(Y)
dp = [[0] * (n + 1) for _ in range(m + 1)]
for j in range(1, n + 1):
for i in pos_dict.get(Y[j - 1], []):
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j - 1] + 1)
for i in range(1, m + 1):
dp[i][j] = max(dp[i][j], dp[i - 1][j])
return dp[m][n]
此方法通过预处理，减少了状态转移时的遍历次数，在特定场景下可提升算法效率。
三、减少冗余计算：优化子问题求解顺序
动态规划中，子问题的求解顺序会影响计算效率。合理安排计算顺序，可避免重复计算已解决的子问题。
以矩阵链乘法为例，其状态转移方程为 dp[i][j] = min(dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j])，其中 (i \leq k < j)。若按照矩阵链长度从小到大的顺序计算，可确保在计算 dp[i][j] 时，所有依赖的子问题 dp[i][k] 和 dp[k + 1][j] 均已求解。
Python 代码
def matrix_chain_order_optimized(p):
n = len(p) - 1
dp = [[0] * (n + 1) for _ in range(n + 1)]
for L in range(2, n + 1):
for i in range(1, n - L + 2):
j = i + L - 1
dp[i][j] = float('inf')
for k in range(i, j):
q = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j]
if q < dp[i][j]:
dp[i][j] = q
return dp[1][n]
Java 代码
public class MatrixChainMultiplicationOptimized {
public static int matrixChainOrderOptimized(int[] p) {
int n = p.length - 1;
int[][] dp = new int[n + 1][n + 1];
for (int L = 2; L <= n; L++) {
for (int i = 1; i <= n - L + 1; i++) {
int j = i + L - 1;
dp[i][j] = Integer.MAX_VALUE;
for (int k = i; k < j; k++) {
int q = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
if (q < dp[i][j]) {
dp[i][j] = q;
}
}
}
}
return dp[1][n];
}
}
这种顺序计算方式保证了每个子问题仅被求解一次，相较于随机顺序，能大幅减少计算时间。
四、记忆化搜索优化：自顶向下的高效实现
对于一些难以确定自底向上计算顺序的问题，可采用记忆化搜索（自顶向下 + 备忘录）的方式。通过记录已求解的子问题结果，避免重复递归计算。
以数字三角形问题为例，从顶部出发，每次可向下或向右下移动，求到达底部的最大路径和。
Python 代码
def max_path_sum_triangle(triangle):
memo = {}
def dfs(i, j):
if (i, j) in memo:
return memo[(i, j)]
if i == len(triangle) - 1:
return triangle[i][j]
down = dfs(i + 1, j)
right_down = dfs(i + 1, j + 1)
memo[(i, j)] = triangle[i][j] + max(down, right_down)
return memo[(i, j)]
return dfs(0, 0)
Java 代码
import java.util.HashMap;
import java.util.Map;
public class MaxPathSumTriangle {
public static int maxPathSumTriangle(int[][] triangle) {
Map<String, Integer> memo = new HashMap<>();
return dfs(triangle, 0, 0, memo);
}
private static int dfs(int[][] triangle, int i, int j, Map<String, Integer> memo) {
String key = i + "," + j;
if (memo.containsKey(key)) {
return memo.get(key);
}
if (i == triangle.length - 1) {
return triangle[i][j];
}
int down = dfs(triangle, i + 1, j, memo);
int rightDown = dfs(triangle, i + 1, j + 1, memo);
int result = triangle[i][j] + Math.max(down, rightDown);
memo.put(key, result);
return result;
}
}
记忆化搜索在保持递归代码简洁性的同时，通过备忘录机制将时间复杂度从指数级降低至多项式级。
动态规划的优化需要深入理解问题本质，灵活运用各种技巧。通过空间压缩、状态转移简化、合理安排计算顺序和记忆化搜索等方法，能够有效提升动态规划算法的效率。在实际应用中，应根据具体问题的特点，综合运用这些技巧，实现最优解决方案。
