动态规划实战:从回文串构造到矩阵链乘优化,用Java攻克PTA经典难题
算法学习路上,动态规划(Dynamic Programming, DP)常常是那道分水岭。很多朋友在初次接触时,会被它“状态”、“转移方程”、“最优子结构”这些术语绕晕,感觉懂了概念,一遇到PTA(程序设计类实验辅助教学平台)上的题目又无从下手。我自己刚开始刷题时也这样,对着“回文串”和“矩阵链相乘”这类题目发愣,明明知道是动态规划,却不知道如何把问题拆解成代码。
这篇文章,我想和你一起,像解谜一样,把这两个PTA上的经典动态规划问题彻底搞懂。我们不只满足于AC(Accept),更要理解背后的设计思路,知道为什么这么定义状态,以及如何写出清晰、高效的Java代码。你会发现,一旦掌握了核心的思考框架,很多动态规划问题都会变得有迹可循。
1. 动态规划思维重塑:从“记忆化搜索”到“自底向上”
在直接切入具体问题前,我们有必要统一一下对动态规划本质的理解。很多人把它等同于“填表格”,这没错,但容易流于形式。我更愿意把它看作一种 “聪明的暴力搜索”。
想象一下,你要计算斐波那契数列的第n项。最直接的递归写法是 fib(n) = fib(n-1) + fib(n-2)。但你会发现,计算 fib(5) 时,fib(3) 被重复计算了多次。动态规划的核心思想就是:把已经解决过的子问题的答案存起来,避免重复计算。
这引出了动态规划的两个关键实现方式:
- 记忆化搜索(自顶向下):在递归函数中,加入一个缓存(比如数组或哈希表),每次计算前先查缓存,算完后存入缓存。这更符合人类的自然思维——从大问题分解到小问题。
- 递推(自底向上):先解决最小的子问题,然后逐步组合,解决更大的问题。这就是我们常说的“填表法”,通常用循环实现,效率更高,也是PTA题目中最常见的考察形式。
对于PTA的编程题,我们通常采用递推方式,因为它代码结构清晰,且避免了递归可能带来的栈溢出风险。一个通用的思考流程可以总结为以下几步:
- 定义状态:用
dp[i]或dp[i][j]这样的数组表示什么?它必须能够描述问题在某个阶段的情况。 - 确定状态转移方程:这是最核心的一步。找出
dp[i]和之前状态(如dp[i-1],dp[i-2]等)之间的关系。这本质上是一个递推公式。 - 初始化:最小的、不可再分的子问题答案是什么?这通常是
dp[0],dp[1]或dp[i][i]的值。 - 确定计算顺序:为了保证在计算当前状态时,它所依赖的子状态都已经被计算出来,我们需要确定正确的循环顺序。
- 返回结果:最终答案对应的是哪个状态?是
dp[n],还是dp[0][m]?
提示:在纸上画一画状态表,手动模拟一下前几步的填充过程,是理解动态规划极其有效的方法,能帮你直观地验证转移方程是否正确。
下面,我们就带着这个“五步思考法”,去破解两个具体的难题。
2. 回文串构造问题:寻找“最长的回文子序列”
PTA上的题目描述通常是:给定一个字符串,可以在任意位置添加字符,求使其变成回文串所需的最少添加字符数。
例如:输入 "Ab3bd",输出 2(可以添加两个字符变成 "dAb3bAd" 或 "Adb3bdA")。
2.1 问题转化与状态定义
直接思考“添加几个字符”可能有点绕。我们换个角度:一个字符串添加字符变成回文串,等价于保留原字符串中的部分字符构成一个回文子序列,然后为不在这个子序列里的字符在对称位置补上对应的字符。
因此,最少添加字符数 = 原字符串长度 - 原字符串中最长回文子序列(Longest Palindromic Subsequence, LPS)的长度。
这样一来,问题就变成了经典的最长回文子序列问题。我们的状态可以定义为:
dp[i][j]:表示字符串 s 中从下标 i 到下标 j(包含两端)的子串中,最长回文子序列的长度。
这里 i 和 j 代表子串的左右边界。我们的目标是求出 dp[0][n-1](n 为字符串长度)。
2.2 推导状态转移方程
如何求 dp[i][j] 呢?我们考虑子串的两端字符 s.charAt(i) 和 s.charAt(j):
-
情况一:两端字符相等。如果
s.charAt(i) == s.charAt(j),那么这两个字符肯定可以成为最终回文子序列的两端。因此,dp[i][j]就等于去掉这两端后中间部分的最长回文子序列长度加2。dp[i][j] = dp[i+1][j-1] + 2; (当 i < j-1)注意边界:当
i == j时,子串只有一个字符,它本身就是回文,长度为1。当i == j-1且字符相等时,回文长度为2。 -
情况二:两端字符不相等。如果
s.charAt(i) != s.charAt(j),那么这两个字符不可能同时作为回文子序列的两端。最长回文子序列要么在s[i+1...j]中,要么在s[i...j-1]中。我们取两者的最大值。dp[i][j] = Math.max(dp[i+1][j], dp[i][j-1]);
2.3 Java实现与细节
根据上面的分析,我们需要一个二维数组 dp。注意计算顺序:由于 dp[i][j] 依赖于 dp[i+1][j-1]、dp[i+1][j] 和 dp[i][j-1],即依赖于“左下”、“下”、“左”三个方向的值。因此,我们需要从下往上、从左往右地遍历,或者固定子串长度,从小到大计算。
以下是采用固定子串长度的Java实现,这种方式逻辑更清晰:
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.next();
int n = s.length();
// dp[i][j] 表示 s[i..j] 的最长回文子序列长度
int[][] dp = new int[n][n];
// 初始化:单个字符的子串,回文长度为1
for (int i = 0; i < n; i++) {
dp[i][i] = 1;
}
// len 表示当前考虑的子串长度,从2开始到n
for (int len = 2; len <= n; len++) {
for (int i = 0; i <= n - len; i++) {
int j = i + len - 1; // 子串右端点
if (s.charAt(i) == s.charAt(j)) {
// 两端字符相等
if (len == 2) {
dp[i][j] = 2; // 只有两个相同字符
} else {
dp[i][j] = dp[i + 1][j - 1] + 2;
}
} else {
// 两端字符不等
dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1]);
}
}
}
// 最少添加字符数 = 原长 - 最长回文子序列长度
int lpsLength = dp[0][n - 1];
int minAdd = n - lpsLength;
System.out.println(minAdd);
sc.close();
}
}
代码要点解析:
- 我们使用
len循环来控制子串长度,确保在计算较长子串时,其内部较短的子串已经计算完毕。 - 当
len=2且两端字符相等时,是一个特殊情况,中间没有子串(i+1 > j-1),直接赋值为2。 - 最终结果
dp[0][n-1]就是整个字符串的最长回文子序列长度。
为了更直观地理解填充过程,我们以字符串 "abbc" 为例,观察 dp 表的最终状态:
| i\j | 0(a) | 1(b) | 2(b) | 3(c) |
|---|---|---|---|---|
| 0 | 1 | 1 | 2 | 2 |
| 1 | - | 1 | 2 | 2 |
| 2 | - | - | 1 | 1 |
| 3 | - | - | - | 1 |
注意:表格中
-表示无效区域(i>j)。dp[0][3]的值为2,最长回文子序列是"bb",所以最少需要添加4 - 2 = 2个字符(如变成"bcb"需要添加一个,但题目要求回文,所以是"bcbcb"? 这里示例可能不完美,但说明了计算过程)。
3. 矩阵链相乘问题:优化计算顺序以节省代价
这是动态规划另一个教科书级的例子。问题描述:给定一系列矩阵 A1, A2, ..., An,其中矩阵 Ai 的维度是 p[i-1] x p[i]。确定一个乘法结合的顺序,使得计算 A1*A2*...*An 所需的总标量乘法次数最少。
例如:三个矩阵维度分别是 10x100, 100x5, 5x50。按 (A1*A2)*A3 计算需要 10*100*5 + 10*5*50 = 5000 + 2500 = 7500 次。按 A1*(A2*A3) 计算需要 100*5*50 + 10*100*50 = 25000 + 50000 = 75000 次。显然第一种顺序更优。
3.1 理解问题与最优子结构
矩阵乘法满足结合律,但不满足交换律。不同的加括号方式(即计算顺序)会导致巨大的计算量差异。关键点在于,最后一次乘法发生的位置。如果我们把矩阵链在位置 k 处分开,变成 (A1...Ak) 和 (A(k+1)...An) 两部分先分别计算,最后再相乘,那么总代价就是:
计算左边链的最小代价 + 计算右边链的最小代价 + 两边结果矩阵相乘的代价。
这完美符合动态规划的“最优子结构”性质:整个问题的最优解包含了其子问题的最优解。
3.2 状态定义与转移方程
我们定义状态:
dp[i][j]:表示计算矩阵链 Ai...Aj(i <= j)所需的最少标量乘法次数。
我们的目标是 dp[1][n](注意,通常输入中矩阵从1开始编号,与数组下标0开始需要做好转换)。
状态转移方程基于“最后一次乘法位置k”的枚举:
dp[i][j] = min{ dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j] },其中 k 的取值范围是 i <= k < j。
这里 p[i-1]*p[k]*p[j] 是合并左右两部分结果矩阵的代价。左部分矩阵维度是 p[i-1] x p[k],右部分矩阵维度是 p[k] x p[j],相乘的代价就是这三个数的乘积。
初始化:当 i == j 时,只有一个矩阵,不需要乘法,所以 dp[i][i] = 0。
3.3 Java实现与计算顺序
计算 dp[i][j] 需要知道它左边和下边的值(因为 k 在 i 和 j 之间)。一种常见的遍历顺序是:按矩阵链的长度 len 从小到大进行。
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); // 矩阵个数
int[] p = new int[n + 1]; // 维度数组,p[0]到p[n]
for (int i = 0; i <= n; i++) {
p[i] = sc.nextInt();
}
// dp[i][j] 表示计算 Ai...Aj 的最小代价,1-based索引
int[][] dp = new int[n + 1][n + 1];
// 初始化:单个矩阵代价为0
for (int i = 1; i <= n; i++) {
dp[i][i] = 0;
}
// len 表示矩阵链的长度(包含的矩阵个数),从2开始
for (int len = 2; len <= n; len++) {
for (int i = 1; i <= n - len + 1; i++) { // 链的起点
int j = i + len - 1; // 链的终点
dp[i][j] = Integer.MAX_VALUE; // 初始化为无穷大
// 枚举分割点k
for (int k = i; k < j; k++) {
int cost = dp[i][k] + dp[k + 1][j] + p[i - 1] * p[k] * p[j];
if (cost < dp[i][j]) {
dp[i][j] = cost;
}
}
}
}
System.out.println(dp[1][n]);
sc.close();
}
}
复杂度分析:三层循环,时间复杂度为 O(n³)。对于PTA题目中 n <= 100 的限制,完全可行。空间复杂度为 O(n²)。
为了加深理解,我们用一个简单例子手动推导。假设 p = [30, 35, 15, 5, 10, 20],对应5个矩阵:A1(30x35), A2(35x15), A3(15x5), A4(5x10), A5(10x20)。
计算 dp[1][5] 需要枚举 k=1,2,3,4:
k=1: cost = dp[1][1]+dp[2][5]+303520 = 0 + ? + 21000k=2: cost = dp[1][2]+dp[3][5]+301520 = (303515) + ? + 9000- ... 最终通过子问题的递推,可以算出最小值为11875。
注意:在实际编程中,我们通常使用1-based索引来处理矩阵编号,这样更直观,但需要小心数组边界。
p数组的长度是n+1,dp数组的维度也是[n+1][n+1],并忽略第0行和第0列。
4. 举一反三:动态规划的常见模式与PTA刷题策略
通过上面两个问题的深入剖析,我们可以看到,尽管问题领域不同(字符串 vs. 线性代数),但其动态规划的解题框架是相通的。在PTA上,动态规划题目还有几种非常高频的类型,掌握其模式能极大提升解题效率。
4.1 经典模型识别
| 问题类型 | 典型PTA题目 | 状态定义核心 | 转移方程特征 |
|---|---|---|---|
| 线性DP | 最大子段和、最长递增子序列 | dp[i] 表示以第i个元素结尾的某种最优解 | 通常只与前面有限个状态相关 |
| 背包问题 | 0-1背包、完全背包 | dp[i][j] 表示前i个物品在容量j下的最优解 | 基于“放”与“不放”的选择 |
| 区间DP | 矩阵链乘、石子合并、回文串 | dp[i][j] 表示区间 [i, j] 上的最优解 | 枚举区间分割点 k |
| 路径/网格DP | 寻宝(数字三角形)、最小路径和 | dp[i][j] 表示到达位置 (i, j) 的最优解 | 来自上方或左方的转移 |
4.2 针对PTA的实战编码技巧
在PTA平台提交Java代码解决动态规划问题时,有几个细节能帮你避免不必要的失分:
-
输入输出效率:当数据量较大时(如
n=10000),使用Scanner可能较慢。可以考虑使用BufferedReader。import java.io.*; public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); String[] firstLine = br.readLine().split(" "); int n = Integer.parseInt(firstLine[0]); // ... 后续处理 } } -
数组大小:根据题目给出的数据范围(如
n<=1000)声明数组,宁可稍微开大一点,避免边界溢出。例如,对于区间DP,数组大小常设为n+5。 -
初始化:务必仔细处理边界条件的初始化。例如,在求“最小值”问题时,通常需要将
dp数组初始化为一个很大的数(如Integer.MAX_VALUE),但要注意后续加法运算可能导致的整数溢出,有时用0x3f3f3f3f这类较大的安全数作为“无穷大”更稳妥。 -
空间优化:有些DP问题,当前状态只与前一两个状态有关,可以用滚动数组将空间复杂度从 O(n²) 降到 O(n) 甚至 O(1)。这在PTA中不一定是必须的,但能体现对算法的深入理解。例如,0-1背包的一维数组优化:
int[] dp = new int[C + 1]; for (int i = 0; i < n; i++) { for (int j = C; j >= weight[i]; j--) { // 注意逆序! dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]); } }
4.3 调试与验证思路
当你写出代码但结果不对时,可以尝试:
- 小数据测试:自己构造几个小的、能口算的测试用例,在本地运行,用打印语句输出关键的
dp表,与手动计算的结果对比。 - 理解样例:PTA的样例输入输出通常涵盖了关键情况(如全负数、边界值)。确保你的程序能通过样例。
- 画图辅助:对于区间DP,在纸上画出矩阵链或字符串区间,标出
i, j, k,有助于检查转移方程是否正确。
动态规划的学习曲线确实比较陡峭,但它的回报也非常丰厚。它不仅是一类重要的算法,更是一种强大的问题分析和分解的思维方式。我在刷了几十道PTA的DP题目后,最大的感触是:不要怕“硬想”。拿到一个新题,先尝试自己定义状态、推导方程,哪怕一开始是错的,这个思考过程的价值远大于直接看题解。回文串和矩阵链相乘这两个问题,就像两把钥匙,帮你打开了动态规划宫殿的两扇大门,门后的世界,还需要你用自己的代码一步步去探索。
343



被折叠的 条评论
为什么被折叠?



