按字典顺序打印所有最长的公共子序列

在字符串处理中，公共子序列是指两个或多个字符串中都存在的子序列。在所有公共子序列中，最长公共子序列（LCS）是指具有最长长度的子序列。本篇文章将介绍如何找到所有最长公共子序列，并按字典顺序打印它们。

解法

最长公共子序列问题可以通过动态规划算法来解决。设 $c_{i,j}$ 表示字符串 $A$ 的前 $i$ 个字符和字符串 $B$ 的前 $j$ 个字符的最长公共子序列长度，有以下递推式：

$$ c_{i,j} = \begin{cases} 0, & i=0 \text{ or } j=0 \ c_{i-1,j-1}+1, & A_i = B_j \ \max{c_{i,j-1},c_{i-1,j}}, & A_i \neq B_j \end{cases} $$

第一行和第一列的边界条件均为 $0$，表示空串和任意串的最长公共子序列都为 $0$。公共子序列的递推态转移分为两种，即当前字符相同和不同两种情况。当 $A_i = B_j$ 时，最长公共子序列可由上一个字符处的最长公共子序列加上当前公共字符得到。当 $A_i \neq B_j$ 时，最长公共子序列可以由 $A$ 中的前 $i-1$ 个字符和 $B$ 中的前 $j$ 个字符的最长公共子序列与 $A$ 中的前 $i$ 个字符和 $B$ 中的前 $j-1$ 个字符的最长公共子序列取较大值得到。

找到最长公共子序列的长度以后，接下来需要从递推矩阵中反向寻找所有的最长公共子序列。反向寻找的过程可以使用递归或是栈。具体来说，如果当前字符相等，说明这个字符在所有最长公共子序列中都会出现，将其加入到结果集。否则，分别从左边和上边两个格子中寻找最长公共子序列。如果两个格子中得到的结果长度相等，则说明当前格子中所有最长公共子序列都是由这两个格子得到的，将两个列表合并后加入结果集中。如果左边的结果长度大于上边的结果长度，则说明当前格子中所有最长公共子序列都是由左边的格子得到的，将左边的列表加入结果集中。如果上边的结果长度大于左边的结果长度，则说明当前格子中所有最长公共子序列都是由上边的格子得到的，将上边的列表加入结果集中。

代码实现

def find_lcs(A, B):
    m, n = len(A), len(B)
    # 计算最长公共子序列长度
    dp = [[0] * (n+1) for _ in range(m+1)]
    for i in range(1, m+1):
        for j in range(1, n+1):
            if A[i-1] == B[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i][j-1], dp[i-1][j])

    # 反向寻找所有最长公共子序列
    def backtrack(i, j):
        if i == 0 or j == 0:
            return [[]]
        if A[i-1] == B[j-1]:
            res = []
            for arr in backtrack(i-1, j-1):
                res.append(arr + [A[i-1]])
            return res
        else:
            lcs1, lcs2 = [], []
            if dp[i][j-1] >= dp[i-1][j]:
                lcs1 = backtrack(i, j-1)
            if dp[i-1][j] >= dp[i][j-1]:
                lcs2 = backtrack(i-1, j)
            return lcs1 + lcs2
    
    # 返回按字典顺序排列的所有最长公共子序列
    lcs = backtrack(m, n)
    lcs_set = set(tuple(seq) for seq in lcs)
    lcs_list = [list(seq) for seq in lcs_set]
    lcs_list.sort()
    return lcs_list

性能分析

时间复杂度：计算最长公共子序列长度需要 $O(mn)$ 的时间，反向寻找所有最长公共子序列需要不超过 $O(2^k)$ 的时间，其中 $k$ 是最长公共子序列的数量。由于任意两个字符串的最长公共子序列数量不会超过 $min(m,n)$，因此总时间复杂度为 $O(mn+2^k)$。

空间复杂度: 动态规划算法需要 $O(mn)$ 的空间，反向寻找最长公共子序列需要不超过 $O(k)$ 的额外空间（递归调用栈的大小），因此总空间复杂度为 $O(mn+k)$。

总结

在字符串处理中，最长公共子序列是一个非常重要的概念。本文提供了一种寻找所有最长公共子序列的算法，并针对输出进行了字典序排序。需要注意的是，虽然本文的代码实现是使用 Python 语言，但是算法本身并不依赖于语言环境，很容易移植到其他语言中。