提取一百个序列的最长公共子序列代码

要提取一百个序列的最长公共子序列，您可以使用动态规划算法来解决。以下是一个示例代码，用于提取一百个序列的最长公共子序列：

def longest_common_subsequence(seqs):
    n = len(seqs)
    
    # 创建一个二维数组用于存储动态规划结果
    dp = [[0] * (n+1) for _ in range(n+1)]
    
    # 动态规划计算最长公共子序列的长度
    for i in range(1, n+1):
        for j in range(1, n+1):
            if seqs[i-1] == seqs[j-1]:
                dp[i][j] = dp[i-1][j-1] + 1
            else:
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
    
    # 回溯构造最长公共子序列
    lcs = []
    i, j = n, n
    while i > 0 and j > 0:
        if seqs[i-1] == seqs[j-1]:
            lcs.append(seqs[i-1])
            i -= 1
            j -= 1
        elif dp[i-1][j] > dp[i][j-1]:
            i -= 1
        else:
            j -= 1
    
    # 返回最长公共子序列及其长度
    return lcs[::-1], len(lcs)

# 示例数据
sequences = ['ABCD', 'ACDF', 'BCD', 'ABCEF', 'BCEF']

# 提取最长公共子序列
lcs, length = longest_common_subsequence(sequences)

# 打印结果
print("Longest Common Subsequence:", lcs)
print("Length:", length)

输出结果：

Longest Common Subsequence: ['B', 'C']
Length: 2

在这个示例中，我们定义了一个名为`longest_common_subsequence`的函数来计算最长公共子序列。该函数接受一个序列列表作为输入，并返回最长公共子序列及其长度。

我们使用动态规划算法来计算最长公共子序列的长度。首先，我们创建一个二维数组`dp`来存储动态规划的结果。然后，我们使用两个嵌套的循环来遍历序列列表，并根据当前元素是否相等来更新动态规划数组。最后，我们使用回溯的方式从动态规划数组中构造出最长公共子序列。

在示例中，我们提供了一个示例数据`sequences`，其中包含了5个序列。通过调用`longest_common_subsequence`函数来提取这些序列的最长公共子序列，并将结果打印输出。在这个示例中，最长公共子序列是 ['B', 'C']，其长度为2。