最长公共子序列(LCS)算法详解与动态规划实现

1. 最长公共子序列问题背景与应用场景

最长公共子序列（Longest Common Subsequence，简称LCS）是计算机科学中经典的字符串处理问题，也是算法竞赛中的常客。给定两个序列X和Y，找出它们共有的最长子序列。与子串不同，子序列不要求连续，但必须保持相对顺序。

这个问题在1974年由Robert A. Wagner和Michael J. Fischer首次提出，其动态规划解法时间复杂度为O(mn)，其中m和n分别是两个序列的长度。LCS算法在多个领域有重要应用：

• 生物信息学：DNA序列比对、蛋白质结构分析
• 版本控制系统：Git等工具中的文件差异比较
• 自然语言处理：文本相似度计算、抄袭检测
• 数据压缩：基于重复模式的压缩算法优化

在蓝桥杯这类算法竞赛中，LCS问题常作为动态规划的基础题目出现，考察选手对状态转移方程的理解和实现能力。题目2086作为VIP题库中的提高组题目，难度适中但极具代表性。

2. 问题分析与动态规划解法设计

2.1 问题形式化定义

给定两个字符串text1和text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回0。

示例：

code复制输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace"，长度为3

2.2 动态规划思路拆解

动态规划解法的核心在于构建一个二维DP表，其中dp[i][j]表示text1前i个字符和text2前j个字符的LCS长度。状态转移方程分为两种情况：

1. 当text1[i-1] == text2[j-1]时：

   code复制dp[i][j] = dp[i-1][j-1] + 1
   

2. 当text1[i-1] != text2[j-1]时：

   code复制dp[i][j] = max(dp[i-1][j], dp[i][j-1])
   

边界条件是dp[0][j] = 0和dp[i][0] = 0，表示任一字符串为空时LCS长度为0。

2.3 空间优化策略

标准解法需要O(mn)空间，但可以优化到O(min(m,n))。观察到计算dp[i][j]时只需要上一行和当前行的数据，因此可以用两行数组滚动计算：

cpp复制int longestCommonSubsequence(string text1, string text2) {
    int m = text1.size(), n = text2.size();
    vector<int> prev(n+1, 0), curr(n+1, 0);
    
    for(int i=1; i<=m; ++i){
        for(int j=1; j<=n; ++j){
            if(text1[i-1] == text2[j-1])
                curr[j] = prev[j-1] + 1;
            else
                curr[j] = max(prev[j], curr[j-1]);
        }
        prev = curr;
    }
    return prev[n];
}

3. C++实现与关键代码解析

3.1 完整AC代码实现

cpp复制#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int longestCommonSubsequence(string text1, string text2) {
    const int m = text1.length();
    const int n = text2.length();
    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]){
                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() {
    string s1, s2;
    cin >> s1 >> s2;
    cout << longestCommonSubsequence(s1, s2) << endl;
    return 0;
}

3.2 关键代码细节说明

1. DP表初始化：创建(m+1)×(n+1)的二维数组，+1是为了包含空字符串的情况
2. 索引处理：字符串从0开始索引，而DP表从1开始，所以比较的是text1[i-1]和text2[j-1]
3. 状态转移：相等时取左上值+1，不等时取左边或上边的最大值
4. 边界处理：第一行和第一列初始化为0，自动处理了空字符串的情况

3.3 复杂度分析

• 时间复杂度：O(mn)，双重循环遍历整个DP表
• 空间复杂度：O(mn)，使用二维数组存储中间结果（可优化为O(n)）

4. 蓝桥杯真题实战与常见变种

4.1 题目2086的输入输出规范

蓝桥杯OJ系统的典型输入格式：

code复制第一行：字符串A
第二行：字符串B
输出：一个整数表示LCS长度

需要注意：

1. 字符串可能包含空格（本题未明确说明时按不含空格处理）
2. 字符串长度通常在1000以内，但VIP题库可能测试更大规模数据
3. 注意换行符处理，建议使用getline读取整行

4.2 常见变种题型

1. 输出LCS字符串：需要回溯DP表构造具体序列

   cpp复制string getLCS(string& text1, string& text2, vector<vector<int>>& dp){
       string res;
       int i = text1.size(), j = text2.size();
       while(i>0 && j>0){
           if(text1[i-1]==text2[j-1]){
               res.push_back(text1[i-1]);
               i--; j--;
           }else if(dp[i-1][j]>dp[i][j-1]){
               i--;
           }else{
               j--;
           }
       }
       reverse(res.begin(), res.end());
       return res;
   }
   

2. 多序列LCS：扩展到三个或更多序列的比较

   cpp复制int LCS3(string& a, string& b, string& c){
       int dp[101][101][101] = {0};
       // 三维DP表处理...
   }
   

3. 带权LCS：不同字符匹配有不同的权重值

4.3 性能优化技巧

1. 滚动数组：如前所述的空间优化
2. 位压缩：对于特定字符集可以利用位运算加速
3. 分治算法：Hirschberg算法可以在O(nlogn)时间解决问题
4. 预处理：对非常长的字符串可以先筛除不可能匹配的字符

5. 动态规划专题训练建议

5.1 推荐练习题目

1. 蓝桥杯历年真题：

   • 最长上升子序列(LIS)
   • 编辑距离
   • 背包问题变种

2. LeetCode经典题目：

   • 1143. 最长公共子序列（本题）
   • 72. 编辑距离
   • 516. 最长回文子序列

3. 进阶挑战：

   • 带限制条件的LCS（如必须包含某些字符）
   • 多字符串LCS
   • 近似匹配问题

5.2 调试与验证技巧

1. 小规模测试：先用简单案例验证基础逻辑

   code复制"a", "a" → 1
   "abc", "def" → 0
   

2. 边界测试：

   • 空字符串输入
   • 完全相同字符串
   • 完全不同的长字符串

3. 打印DP表：对于WA的案例，打印整个DP表分析错误点

5.3 竞赛中的时间分配建议

1. 5分钟：分析问题，确定算法框架
2. 10分钟：编写基础DP解法
3. 5分钟：测试样例和边界条件
4. 5分钟：考虑空间优化（如有余力）

对于蓝桥杯等竞赛，建议先确保基础解法正确，再考虑优化。遇到LCS变种问题时，先思考标准LCS的解法如何扩展，通常状态定义和转移方程会有相似之处。