最长公共子序列（LCS）

问题描述

最长公共子序列（Longest Common Subsequence，LCS）问题是一个经典的计算机科学问题，它寻找两个序列共有的最长子序列。这里的“子序列”是指在不改变序列元素的相对顺序的情况下，通过删除一些元素（也可能一个都不删）形成的新序列。注意，子序列不同于子串，子串要求元素在原序列中是连续的，而子序列不要求连续。

eg：A = "ABCD" 和 B = "ABACD"，它们的公共子序列是 "ABCD" 。

在这篇文章中，我们求解两个问题：

1. 子序列的长度

2. 得到最长的子序列

1.子序列的长度

集合表示：f[i][j]表示 a 的前 i 个字母，和 b 的前 j 个字母的最长公共子序列长度。

集合划分：a[i] , b[j] 是否包含在子序列中。

有以下四种情况;

1. a[i] 和 b[j] 均不在。f[i][j] = f[i-1][j-1] 。

2. a[i] 不在，b[j] 在。f[i][j] = f[i-1][j] 。

3. a[i] 在，b[j] 不在。f[i][j] = f[i][j-1] 。

4. a[i] 在，b[j] 在。f[i][j] = f[i-1][j-1]+1 。

注：

对于情况2，实际上无法用 f[i-1][j] 表示，因为 f[i−1][j] 表示的是在a的前i-1个字母中出现，并且在 b 的前 j 个字母中出现,此时 b[j] 不一定出现，这与条件不完全相等，条件给定是 a[i] 一定不在子序列中，b[j] 一定在子序列当中，但仍可以用 f[i−1][j] 来表示，原因就在于条件给定的情况被包含在 f[i−1][j] 中，即条件的情况是 f[i−1][j] 的子集，而求的是max，所以对结果不影响。情况3也是如此。

代码实现：

#include <iostream>
using namespace std;
#include <algorithm>
#include <cstdio>

const int N = 1010;

int n,m;
char a[N],b[N];
int f[N][N];

int main()
{
    scanf("%d%d",&n,&m);
    scanf("%s%s",a+1,b+1);
    
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= m;j++)
        {
            f[i][j] = max(f[i-1][j],f[i][j-1]);
            if(a[i] == b[j]) f[i][j] = max(f[i][j],f[i-1][j-1]+1);
        }
    cout << f[n][m] << endl;
    return 0;
}

2.得到最长的子序列

采用回溯法得到最长的公共子序列。下面介绍回溯法的核心思想：

从动态规划的终点 f[n][m] 开始，逐步向前回溯，根据 f[i][j] 的值决定如何移动。

每次回溯时，判断当前字符是否属于最长公共子序列：

        如果 a[i] == b[j] ，则当前字符是LCS的一部分，记录下来，并同时移动 i 和 j 。

        如果 a[i] == b[j] ，则根据 f[i-1][j] 和 f[i][j-1] 的值决定如何移动方向：

                如果f[i-1][j] > f[i][j-1] 则向上移动 i 。

                否则，向左移动 j 。

代码实现：

#include <iostream>
using namespace std;
#include <algorithm>
#include <cstdio>

const int N = 1010;

int n, m;
char a[N], b[N];
int f[N][N];
char lcs[N];

int main()
{
    scanf("%d%d", &n, &m);
    scanf("%s%s", a + 1, b + 1);
    
    // 动态规划求解最长公共子序列的长度
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            f[i][j] = max(f[i - 1][j], f[i][j - 1]);
            if (a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
        }
    
    // 输出最长公共子序列的长度
    cout << f[n][m] << endl;
    
    // 回溯构造最长公共子序列
    int i = n, j = m;
    int index = f[n][m];
    lcs[index] = '\0';  // 字符串结束符
    
    while (i > 0 && j > 0)
    {
        if (a[i] == b[j])
        {
            lcs[index - 1] = a[i];
            i--;j--;index--;
        }
        else if (f[i - 1][j] > f[i][j - 1]) i--;
        else j--;
    }
    
    cout << "最长公共子序列: " << lcs << endl;
    
    return 0;
}