最长公共子序列
最长公共子序列(Longest Common Subsequence,简称LCS)是计算机科学中一个非常经典的算法问题,也是动态规划(Dynamic Programming, DP)的入门必学案例。它在 DNA 序列比对、Git 版本控制(找代码差异)以及文件相似度对比中都有广泛应用。
下面为你系统梳理 LCS 的核心知识点:
1. 先搞懂概念:子序列 vs 子串
很多初学者会把这两个概念搞混,这是理解 LCS 的第一道门槛。
- 子串(Substring):必须是连续的字符。
- 例如:对于字符串
"abcdef","abc"和"cde"是它的子串,但"ace"不是。
- 例如:对于字符串
- 子序列(Subsequence):不要求连续,只要求保持原有的相对先后顺序。
- 例如:对于
"abcdef","ace"和"bdf"都是它的子序列(可以跳过中间的字符)。
- 例如:对于
最长公共子序列(LCS):给定两个序列(或字符串)A 和 B,找出它们所有的公共子序列中,长度最长的那一个。
- 注意:最长公共子序列可能不止一个,但它们的长度是唯一的。
- 例子:序列 A =
"ABCBDAB",序列 B ="BDCABA"。它们的 LCS 可以是"BCBA"或"BDAB",长度都是 4。
2. 为什么用动态规划?
要暴力求解 LCS,我们需要穷举 A 的所有子序列(2^m 个),去 B 里查(O(n)),时间复杂度高得离谱。但这个问题有一个很好的性质:最优子结构和重叠子问题。也就是说,大问题的最优解可以由小问题的最优解推导出来。这正是动态规划的用武之地。
3. 动态规划的核心(两步走)
第一步:定义状态
我们用一个二维数组dp[i][j]来表示状态。定义:dp[i][j]表示字符串 A 的前i个字符,和字符串 B 的前j个字符,它们的最长公共子序列的长度。(注意:这里的i和j指的是长度,比如i=1代表 A 的第1个字符 A[0])
第二步:状态转移方程(核心逻辑)
当我们要求dp[i][j]时,我们只看 A 的第i个字符(即A[i-1])和 B 的第j个字符(即B[j-1]):
-
情况 1:字符相等(
A[i-1] == B[j-1])既然这两个字符相等,它们肯定可以作为当前公共子序列的最后一个字符。所以我们只需要看它们前面的字符能构成多长的 LCS,然后加上这 1 个即可。方程:dp[i][j] = dp[i-1][j-1] + 1 -
情况 2:字符不相等(
A[i-1] != B[j-1])既然不相等,它们不可能同时出现在同一个公共子序列的结尾。那我们就只能在以下两种选择中挑一个最长的:- 要么丢弃 A 的当前字符,看 A 的前
i-1个字符和 B 的前j个字符的 LCS。 - 要么丢弃 B 的当前字符,看 A 的前
i个字符和 B 的前j-1个字符的 LCS。方程:dp[i][j] = max( dp[i-1][j], dp[i][j-1] )
- 要么丢弃 A 的当前字符,看 A 的前
第三步:边界初始化
如果 A 或 B 是空字符串,那么 LCS 长度肯定是 0。所以:dp[0][j] = 0(A 长度为0);dp[i][0] = 0(B 长度为0)。
4. 极简推演示例
非常抱歉,Markdown 表格如果单元格内文字过长(尤其是包含公式、符号或中英文混排时),确实很容易在部分渲染器里错位或换行导致混乱。
为了绝对保证排版不乱,我把第4部分的推演改为“极简数据表格 + 纯代码块矩阵 + 文字推导”的组合形式。这样在任何 Markdown 预览里都能完美展示。
以下是修改后的第 4 部分:
4. 极简推演示例
假设 A = "abc",B = "abd"。我们画一个表格看 dp 的过程。
首先,我们只展示最终计算出来的 dp 数组结果:
| i \ j | 0 | 1 (a) | 2 (b) | 3 (d) |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 1 (a) | 0 | 1 | 1 | 1 |
| 2 (b) | 0 | 1 | 2 | 2 |
| 3 (c) | 0 | 1 | 2 | 2 |
推算过程文字解析:
- 第 0 行和第 0 列:由于代表空字符串,所以全部初始化为
0。 - 计算
dp[1][1](即 A='a', B='a'):A[0] == B[0]('a' == 'a'),使用公式dp[0][0] + 1=0 + 1= 1。
- 计算
dp[1][2](即 A='a', B='ab'):A[0] != B[1]('a' != 'b'),使用公式max(dp[0][2], dp[1][1])=max(0, 1)= 1。
- 计算
dp[2][2](即 A='ab', B='ab'):A[1] == B[1]('b' == 'b'),使用公式dp[1][1] + 1=1 + 1= 2。
- 计算
dp[3][3](即 A='abc', B='abd'):A[2] != B[2]('c' != 'd'),使用公式max(dp[2][3], dp[3][2])=max(2, 2)= 2。
最终右下角的 dp[3][3] = 2,所以 "abc" 和 "abd" 的 LCS 长度是 2(即 "ab")。
5. 代码实现(Python 与 C++)
Python 版本
def longest_common_subsequence(text1, text2):
m, n = len(text1), len(text2)
# 创建一个 (m+1) x (n+1) 的二维数组,初始全为 0
# dp[i][j] 表示 text1前i个 和 text2前j个 的LCS长度
dp = [[0] * (n + 1) for _ in range(m + 1)]
for i in range(1, m + 1):
for j in range(1, n + 1):
if text1[i - 1] == text2[j - 1]:
# 字符相等,左上角的值 + 1
dp[i][j] = dp[i - 1][j - 1] + 1
else:
# 字符不等,取上方或左方的最大值
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
# 右下角的值就是最终答案
return dp[m][n]
# 测试
print(longest_common_subsequence("abcde", "ace")) # 输出: 2 (即 "ace")
C++ 版本
#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;
int longestCommonSubsequence(string text1, string text2) {
int m = text1.length();
int n = text2.length();
// 创建一个 (m+1) x (n+1) 的二维向量,初始值为 0
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (text1[i - 1] == text2[j - 1]) {
// 字符相等,左上角的值 + 1
dp[i][j] = dp[i - 1][j - 1] + 1;
} else {
// 字符不等,取上方或左方的最大值
dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
}
}
}
// 右下角的值就是最终答案
return dp[m][n];
}
int main() {
// 测试
cout << longestCommonSubsequence("abcde", "ace") << endl; // 输出: 2
return 0;
}
6. 复杂度分析
- 时间复杂度:O(m * n)。其中 m 和 n 分别是两个字符串的长度。我们需要填满整个二维表格,每个格子花费 O(1) 的时间。
- 空间复杂度:O(m * n)。因为我们需要一个二维数组来存储状态。
- (进阶优化):其实在计算
dp[i][j]时,我们只依赖于上一行(i-1)和当前行的前一个(j-1)。因此,可以使用滚动数组将空间复杂度优化到O(min(m, n)),这在处理超长字符串(比如 DNA)时非常有用。
- (进阶优化):其实在计算
总结
LCS 的关键就在于那个二维表格的推导:“字符相等看左上角加一,字符不等看上方和左方的最大值。”记住了这个套路,再看其他类似的双序列动态规划问题(比如编辑距离),你会发现它们如出一辙。

浙公网安备 33010602011771号