数据结构与算法之最长公共子序列

最长公共子序列（LCS）是指给定两个序列X和Y，找出一个最长的子序列既是X的子序列也是Y的子序列。子序列是指在序列中删去任意个元素而不改变其他元素顺序得到的新序列。

LCS问题可以使用动态规划求解。假设x[1…m]和y[1…n]是两个序列，令c[i,j]表示x[1…i]和y[1…j]的LCS长度，则有以下状态转移方程：

• 当i=0或j=0时，c[i,j]=0；
• 当x[i]=y[j]时，c[i,j]=c[i-1,j-1]+1；
• 当x[i]!=y[j]时，c[i,j]=max(c[i,j-1],c[i-1,j])。

根据上述方程，可以使用一个二维数组c来存储每个子问题的解，从而只需要计算一次就可以在O(mn)的时间复杂度内求出LCS的长度。

求出LCS的长度之后，可以通过回溯求出具体的LCS序列。从c[m,n]开始，不断向左上方移动，如果x[i]=y[j]，则将x[i]加入LCS序列中，直到回溯到c[0,0]为止。

一、C 实现 最长公共子序列 及代码详解

下面是 C 语言实现最长公共子序列的代码：

#include <stdio.h>
#include <string.h>

#define MAX_LEN 100

int max(int a, int b) {
    return a > b ? a : b;
}

void lcs(char *s1, char *s2, int m, int n) {
    int dp[MAX_LEN][MAX_LEN];
    int i, j, k;

    memset(dp, 0, sizeof(dp));

    for (i = 1; i <= m; i++) {
        for (j = 1; j <= n; j++) {
            if (s1[i-1] == s2[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }

    printf("Length of LCS: %d\n", dp[m][n]);

    char lcs[MAX_LEN];
    k = dp[m][n];
    i = m;
    j = n;

    while (k > 0) {
        if (s1[i-1] == s2[j-1]) {
            lcs[k-1] = s1[i-1];
            i--;
            j--;
            k--;
        } else if (dp[i-1][j] > dp[i][j-1]) {
            i--;
        } else {
            j--;
        }
    }

    printf("LCS: %s\n", lcs);
}

int main() {
    char s1[MAX_LEN], s2[MAX_LEN];
    int m, n;

    printf("Input first string: ");
    fgets(s1, MAX_LEN, stdin);
    m = strlen(s1);
    if (s1[m-1] == '\n')
        s1[m-1] = '\0';
    m--;

    printf("Input second string: ");
    fgets(s2, MAX_LEN, stdin);
    n = strlen(s2);
    if (s2[n-1] == '\n')
        s2[n-1] = '\0';
    n--;

    lcs(s1, s2, m, n);

    return 0;
}

代码解释：

• max() 函数用于求两个数的最大值；
• lcs() 函数接收两个字符串 s1 和 s2、两个字符串的长度 m 和 n；
• 声明一个二维数组 dp，每个元素 dp[i][j] 表示第一个字符串前 i 个字符和第二个字符串前 j 个字符的最长公共子序列长度；
• 初始化 dp 为全 0，因为两个空字符串的最长公共子序列为 0；
• 遍历 dp 数组，当两个字符相等时，dp[i][j] 等于两个子串去掉最后一个字符后的最长公共子序列长度加上 1；否则，dp[i][j] 等于两个子串分别去掉最后一个字符后的最大值；
• 计算出最长公共子序列长度后，声明一个 lcs 数组用于储存最长公共子序列；
• 根据 dp 数组，从后往前遍历两个字符串，将当前字符加入 lcs 数组，并向左上方移动，直到 lcs 数组被填满；
• 最后输出最长公共子序列。

使用 fgets() 函数读取字符串，注意去掉字符串尾部的换行符。

二、C++ 实现 最长公共子序列 及代码详解

最长公共子序列（LCS）是一道常见的算法问题，用于寻找两个字符串（或序列）的最长公共子序列。

C++ 代码实现：

#include <iostream>
#include <cstring>
using namespace std;

const int MAX_N = 1000;

int dp[MAX_N][MAX_N];

int lcs(string a, string b) {
    int n = a.size();
    int m = b.size();

    memset(dp, 0, sizeof(dp));

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (a[i - 1] == b[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[n][m];
}

int main() {
    string a, b;
    cin >> a >> b;

    int ans = lcs(a, b);
    cout << ans << endl;

    return 0;
}

代码详解：

1. 定义常量 MAX_N 表示两个字符串的最大长度，初始化 dp 数组。
2. 定义 lcs 函数，其中 n, m 分别表示两个字符串的长度，使用 memset 将 dp 数组初始化为 0。
3. 使用两个 for 循环遍历两个字符串，当 a[i-1] == b[j-1] 时，说明当前字符相同，所以最长公共子序列长度加 1，即 dp[i-1][j-1] + 1。
4. 否则说明当前字符不同，所以最长公共子序列长度为 dp[i-1][j] 和 dp[i][j-1] 的最大值。
5. 最终返回 dp[n][m] 即可得到最长公共子序列长度。
6. 在主函数中输入两个字符串，调用 lcs 函数并输出结果。

三、Java 实现 最长公共子序列 及代码详解

最长公共子序列（Longest Common Subsequence，LCS）是指两个序列中都出现过的最长子序列。LCS 问题是典型的动态规划问题。

使用动态规划的思想，我们可以定义二维数组 dp[m][n]，其中 m 和 n 分别表示两个序列的长度。dp[i][j] 表示序列 1 中前 i 个元素与序列 2 中前 j 个元素的最长公共子序列的长度。

根据 LCS 的定义，我们可以得到以下状态转移方程：

当序列 1 中第 i 个元素等于序列 2 中的第 j 个元素时，dp[i][j] = dp[i-1][j-1] + 1

当序列 1 中第 i 个元素不等于序列 2 中的第 j 个元素时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])

根据状态转移方程，我们可以使用双重循环来填充 dp 数组，最终得到 dp[m][n] 即为两个序列的最长公共子序列长度。接下来我们可以根据 dp 数组回溯出具体的最长公共子序列。

以下是 Java 代码实现：

public class LCS {

    public static void main(String[] args) {
        String s1 = "ABCBDAB";
        String s2 = "BDCABA";
        int len = lcs(s1, s2);
        System.out.println("最长公共子序列长度为：" + len);
    }

    public static int lcs(String s1, String s2) {
        int m = s1.length(), n = s2.length();
        int[][] dp = new int[m + 1][n + 1];
        // 初始化 dp 数组
        for (int i = 0; i <= m; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= n; j++) {
            dp[0][j] = 0;
        }
        // 填充 dp 数组
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        // 回溯出最长公共子序列
        StringBuilder sb = new StringBuilder();
        int i = m, j = n;
        while (i > 0 && j > 0) {
            if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
                sb.append(s1.charAt(i - 1));
                i--;
                j--;
            } else if (dp[i - 1][j] >= dp[i][j - 1]) {
                i--;
            } else {
                j--;
            }
        }
        System.out.println("最长公共子序列为：" + sb.reverse().toString());
        return dp[m][n];
    }
}

在我们以上述字符串 “ABCBDAB” 和 “BDCABA” 为例，运行该程序输出如下：

最长公共子序列为：BDAB
最长公共子序列长度为：4

以上代码实现了最长公共子序列的求解，同时还回溯出了具体的最长公共子序列。