本文着重介绍最长公共子序列（LCS）问题的动态规划解法，给出C++实现代码。阐述了子序列和子串等基本概念，介绍了LCS算法步骤，还对其进行性能优化，包括空间、时间优化等。此外，还讲解了算法变种，如最长公共子数组、最短公共超序列等。
文章将着重介绍最长公共子序列（LCS）问题的动态规划解法，并提供C++实现代码。
公共子序列算法详解
引言
在计算机科学中，公共子序列问题是一个经典问题，常用于比较两个序列的相似度，广泛应用于生物信息学、文本编辑距离计算等领域。本文将重点介绍最长公共子序列（LCS）的算法，并提供C++代码示例。
基本概念
子序列和子串
- **子序列**：序列 `X` 的子序列是从 `X` 删除一些（或不删除）元素而不改变其余元素的相对顺序得到的新序列。
- **子串**：序列 `X` 的子串是从 `X` 中提取连续的一部分元素得到的序列。
最长公共子序列（LCS）
给定两个序列 `X` 和 `Y`，找出它们所有子序列中最长的共同子序列。例如，对于 `X = "ABCBDAB"` 和 `Y = "BDCAB"`，一个LCS是 `"BCAB"`。
动态规划求解LCS
动态规划是解决LCS问题的一种有效方法。通过构建一个二维数组，我们可以存储两个序列的所有可能的子序列匹配的长度。
LCS算法的步骤
1. **初始化**：创建一个 `(m+1) x (n+1)` 的矩阵 `L`，其中 `m` 和 `n` 分别是序列 `X` 和 `Y` 的长度。`L[i][j]` 表示 `X[0...i-1]` 和 `Y[0...j-1]` 的LCS长度。
2. **填充矩阵**：根据以下规则填充矩阵：
- 如果 `i` 或 `j` 为0，则 `L[i][j] = 0`。
- 如果 `X[i-1] == Y[j-1]`，则 `L[i][j] = L[i-1][j-1] + 1`。
- 否则，`L[i][j] = max(L[i-1][j], L[i][j-1])`。
C++代码实现
#include <iostream>
#include <vector>
#include <string>
// 函数用于计算两个字符串的LCS长度
int lcs(const std::string &X, const std::string &Y) {
int m = X.size();
int n = Y.size();
std::vector<std::vector<int>> L(m + 1, std::vector<int>(n + 1));
for (int i = 0; i <= m; i++) {
for (int j = 0; j <= n; j++) {
if (i == 0 || j == 0)
L[i][j] = 0;
else if (X[i - 1] == Y[j - 1])
L[i][j] = L[i - 1][j - 1] + 1;
else
L[i][j] = std::max(L[i - 1][j], L[i][j - 1]);
}
}
return L[m][n];
}
int main() {
std::string X = "ABCBDAB";
std::string Y = "BDCAB";
std::cout << "Length of LCS is " << lcs(X, Y) << std::endl;
return 0;
}性能优化
尽管动态规划（DP）是解决最长公共子序列（LCS）问题的一个有效方法，它的时间复杂度为 O(m×n)，其中 m 和 n 是两个序列的长度，而空间复杂度也是 O(m×n)。这种算法在处理较长的序列时可能会遇到性能瓶颈。
1. 空间优化
滚动数组技术： 在计算当前行的DP值时，你只需要前一行的信息。因此，可以将二维数组压缩为一维数组，交替使用两个一维数组或仅使用一个一维数组加以更新。这种方法可以将空间复杂度从 O(m×n) 降低到 O(min(m,n))。
#include <vector>
#include <string>
#include <algorithm>
int lcs_space_optimized(const std::string& X, const std::string& Y) {
if (X.size() < Y.size())
return lcs_space_optimized(Y, X);
std::vector<int> current(Y.size() + 1, 0);
std::vector<int> previous(Y.size() + 1, 0);
for (int i = 1; i <= X.size(); i++) {
current.swap(previous);
for (int j = 1; j <= Y.size(); j++) {
if (X[i - 1] == Y[j - 1])
current[j] = previous[j - 1] + 1;
else
current[j] = std::max(previous[j], current[j - 1]);
}
}
return current[Y.size()];
}
2. 时间优化
Four Russians Technique： 这是一种加速动态规划算法的技术，通过在小块内预处理DP值来减少所需的操作数。该技术将输入分割成小块，并且预计算每个可能的块的结果。这种方法在实际应用中比较复杂，但可以显著减少大输入上的计算时间。
基本思路
Four Russians Technique 将大型问题分解成许多较小的子问题，这些子问题可以独立解决并快速合并。对于 LCS 问题，这意味着将输入序列分割成较小的块，并预处理所有可能的块对的 LCS 长度。这些预处理结果随后用于快速构建原问题的解。
分块和预处理
1. 分块：将两个序列 X\和 Y 均匀分割成长度为 t 的多个块。长度 t 的选择取决于序列的大小和可用内存，通常 t 超过根号 n（其中 n 是序列长度）时效果最佳。
2. 预处理：对于每一对可能的块（来自 X 和 Y），计算它们之间的所有可能的 LCS 长度，并将结果存储在一个表中。这个预处理步骤是算法中最耗时的部分，但只需要执行一次。
动态规划优化
使用预处理的结果，可以在计算 DP 表时跳过一些步骤。具体地，当填充 DP 表的一部分时，可以直接查询预处理表，找到对应块的结果，从而避免了大量的单步计算。
实际实现
这种方法在实际实现时相对复杂，因为它要求程序员管理大量的预处理数据，并精确控制数据在内存中的布局。以下是使用 Four Russians Technique 优化 LCS 算法的一个简化示例：
#include <iostream>
#include <vector>
#include <string>
std::vector<std::vector<int>> preprocess_blocks(const std::string& X, const std::string& Y, int block_size) {
int x_blocks = (X.size() + block_size - 1) / block_size;
int y_blocks = (Y.size() + block_size - 1) / block_size;
std::vector<std::vector<int>> precomputed(x_blocks * y_blocks, std::vector<int>(block_size * block_size, 0));
// 实际预处理过程，用于填充 precomputed 数组
// ...
return precomputed;
}
// 实际的动态规划函数，使用预处理数据
int lcs_with_four_russians(const std::string& X, const std::string& Y, const std::vector<std::vector<int>>& precomputed, int block_size) {
int m = X.size();
int n = Y.size();
std::vector<std::vector<int>> L(m + 1, std::vector<int>(n + 1, 0));
// 使用预处理结果加速 DP 计算
// ...
return L[m][n];
}
int main() {
std::string X = "ABCBDAB";
std::string Y = "BDCAB";
int block_size = 2; // 示例块大小
auto precomputed = preprocess_blocks(X, Y, block_size);
std::cout << "Length of LCS is " << lcs_with_four_russians(X, Y, precomputed, block_size) << std::endl;
return 0;
}Four Russians Technique 虽然在理论上能显著提高大规模数据的处理速度，但其实现复杂度和对内存的要求较高。因此，这种技术在特定情况下（例如，在高性能计算或特定类型的优化问题中）非常有用，但可能不适合所有应用场景。在实际应用这种方法之前，评估问题规模和可用资源是非常重要的。
3.使用更高效的数据结构
Segment Trees 和 Binary Indexed Trees
在动态环境中，如需频繁地插入、删除或修改序列中的元素，传统的动态规划解决方案可能会遇到效率问题，因为每次更改都可能需要重新计算整个解。此时，数据结构如线段树（Segment Trees）和树状数组（Binary Indexed Trees, BIT或Fenwick Tree）显得尤为重要，因为它们可以有效地处理区间查询和更新操作。
线段树（Segment Trees）
线段树是一种二叉树结构，用于存储区间或线段，并允许快速查询和修改区间内的数据。它非常适用于解决区间查询问题，例如区间最大值、最小值、总和等。
适用性：
当需要处理范围查询并对数据进行修改时，线段树是非常有用的，因为它可以在 O(log n) 的时间内进行插入、删除和查询操作。
LCS 优化：
在LCS问题的动态版本中，如果序列经常更改，可以使用线段树来维护动态区间的LCS计算。每个节点可以表示一个序列的子区间，并存储该子区间的LCS信息。
树状数组（Binary Indexed Trees, BIT）
树状数组或Fenwick树提供了一种有效的方法来计算前缀和，同时支持动态的元素更新。它的空间效率和处理速度通常优于线段树，尤其是在数据量较小的情况下。
适用性：
当问题可以被分解为前缀和形式，并需要频繁更新数据时，树状数组是一个理想的选择。
LCS 优化：
虽然树状数组直接应用于LCS计算不太常见，但它可以用于相关问题，如计算修改后的序列对结果的影响。例如，在编辑距离问题中，可以使用树状数组来快速更新和查询操作的结果。
实现示例：线段树用于动态LCS
下面是使用线段树来维护字符串的动态LCS的一个简化示例：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// 定义线段树节点
struct SegmentTreeNode {
int lcs;
// 其他必要的属性
SegmentTreeNode() : lcs(0) {}
};
void buildTree(vector<SegmentTreeNode>& tree, int node, int start, int end, const string& X) {
if (start == end) {
// 初始化单个元素
} else {
int mid = (start + end) / 2;
buildTree(tree, 2 * node + 1, start, mid, X);
buildTree(tree, 2 * node + 2, mid + 1, end, X);
tree[node].lcs = max(tree[2 * node + 1].lcs, tree[2 * node + 2].lcs);
}
}
void updateTree(vector<SegmentTreeNode>& tree, int node, int start, int end, int idx, char value) {
if (start == end) {
// 更新逻辑
} else {
int mid = (start + end) / 2;
if (start <= idx && idx <= mid) {
updateTree(tree, 2 * node + 1, start, mid, idx, value);
} else {
updateTree(tree, 2 * node + 2, mid + 1, end, idx, value);
}
tree[node].lcs = max(tree[2 * node + 1].lcs, tree[2 * node + 2].lcs);
}
}
int main() {
string X = "ABCBDAB";
vector<SegmentTreeNode> tree(4 * X.size());
buildTree(tree, 0, 0, X.size() - 1, X);
// 假设要更新的
操作和查询操作
return 0;
}这个例子中，我们简化了线段树的结构和功能，仅展示了其基本框架。在实际应用中，每个节点可能需要存储更多的信息，并且实现细节会根据具体问题进行调整。使用这些高效的数据结构，可以显著提高动态或在线问题的处理性能，尤其是在涉及复杂序列操作和频繁更新的场景中。
4.预处理策略
预处理重复数据
在解决序列比较问题，如最长公共子序列（LCS）问题时，如果需要频繁比较相同的序列片段，重复的计算不仅耗时，还会大大降低算法的效率。通过采用预处理策略，即预先计算并存储这些序列片段的LCS结果，我们可以显著提高算法的性能。这种方法特别适用于有大量重复或相似查询的场景，如基因序列分析、文本比较工具或任何涉及重复模式匹配的应用。
实现方法
使用哈希表来存储之前计算过的LCS结果是一个有效的策略。这样，当再次遇到相同的序列对时，可以直接从哈希表中查找结果，而无需重新进行计算。
步骤
1. 定义键：将序列对 (X, Y)`或其特征编码作为哈希表的键。
2. 计算并存储结果：在首次计算任何序列对的LCS时，将结果存储在哈希表中。
3. 查找优化：在后续操作中，首先检查哈希表是否已存在当前序列对的结果，如果存在，直接使用存储的结果；如果不存在，再进行计算并更新哈希表。
C++ 示例代码
下面是一个简化的示例，展示如何使用 unordered_map 来存储和查找LCS结果，以减少重复计算：
#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>
#include <utility>
// 定义一个用于存储LCS结果的哈希表
using PairHash = std::unordered_map<std::pair<std::string, std::string>, int, boost::hash<std::pair<std::string, std::string>>>;
// 动态规划计算LCS
int computeLCS(const std::string& X, const std::string& Y) {
int m = X.length(), n = Y.length();
std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (X[i - 1] == Y[j - 1])
dp[i][j] = dp[i - 1][j - 1] + 1;
else
dp[i][j] = std::max(dp[i - 1][j], dp[i][j - 1]);
}
}
return dp[m][n];
}
// 检查哈希表并计算LCS
int getOrComputeLCS(const std::string& X, const std::string& Y, PairHash& cache) {
std::pair<std::string, std::string> key = {X, Y};
// 检查是否已经在缓存中
auto it = cache.find(key);
if (it != cache.end()) {
return it->second; // 直接返回已存储的结果
}
int result = computeLCS(X, Y); // 计算LCS
cache[key] = result; // 存储结果
return result;
}
int main() {
PairHash lcsCache; // 创建哈希表存储LCS结果
std::string X = "ABCBDAB";
std::string Y = "BDCAB";
int lcsLength = getOrComputeLCS(X, Y, lcsCache);
std::cout << "LCS Length: " << lcsLength << std::endl;
// 再次查询相同的序列，应直接从缓存获取结果
lcsLength = getOrComputeLCS(X, Y, lcsCache);
std::cout << "LCS Length from cache: " << lcsLength << std::endl;
return 0;
}总结
这种预处理策略可以显著加快序列比较任务的处理速度，特别是在面对大量重复数据时。哈希表的使用提供了一种快速查找和更新的方法，确保每个序列对的LCS只计算一次。这种方法在提高效率的同时，也节省了计算资源，对于处理复杂或大数据集尤为重要。
算法变种
最长公共子数组（Longest Common Subarray）
最长公共子数组问题关注的是在两个序列中找到最长的连续相同元素序列。这种问题在多个技术领域，如图像处理和信号处理中尤为重要，因为它有助于识别两个数据集之间的直接相似性。
应用背景
图像处理：在比较两张图片的相似度时，可以将图像转换为像素的数值序列，然后查找最长的连续匹配序列。
信号处理：在分析如声音波形或地震数据时，通过寻找连续的相似数据模式来识别重要的模式或异常。
动态规划解法
动态规划是解决最长公共子数组问题的一种有效方法。通过构建一个动态规划表，可以系统地计算并跟踪两个序列间的连续匹配长度。
算法步骤
1. 初始化：
创建一个二维数组 `dp`，其大小为 `(m+1) x (n+1)`，其中 `m` 和 `n` 分别是两个序列的长度。
初始化所有 `dp[i][0]` 和 `dp[0][j]` 的值为 `0`。
2. 填充动态规划表：
遍历序列 `A` 和 `B` 的每个元素。
对于每一对元素 `(A[i-1], B[j-1])`：
如果元素相等 (`A[i-1] == B[j-1]`)，则 `dp[i][j] = dp[i-1][j-1] + 1`。
如果不相等，将 `dp[i][j]` 设置为 `0`，因为公共子数组需要元素连续匹配。
在填充过程中，跟踪 `dp` 表中的最大值及其位置，以便后续可以提取最长的公共子数组。
3. 提取最长子数组：
使用记录的最大值位置反向追踪，从 `dp` 表中提取出最长公共子数组。
C++ 实现示例
#include <iostream>
#include <vector>
#include <algorithm>
std::vector<int> longestCommonSubarray(const std::vector<int>& A, const std::vector<int>& B) {
int m = A.size(), n = B.size();
std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
int max_length = 0, end_index = -1;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (A[i - 1] == B[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
if (dp[i][j] > max_length) {
max_length = dp[i][j];
end_index = i - 1;
}
} else {
dp[i][j] = 0;
}
}
}
// 构建最长公共子数组
std::vector<int> result;
if (max_length > 0) {
result.resize(max_length);
std::copy(A.begin() + end_index - max_length + 1, A.begin() + end_index + 1, result.begin());
}
return result;
}
int main() {
std::vector<int> A = {1, 2, 8, 4, 5};
std::vector<int> B = {8, 9, 8, 4, 5, 6};
std::vector<int> result = longestCommonSubarray(A, B);
std::cout << "Longest Common Subarray: ";
for (int num : result) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}这个动态规划实现不仅有效地解决了最长公共子数组问题，还通过适当的数据结构选择，确保了算法的效率和结果的准确性。这种方法特别适用于需要精确比较和快速响应的应用场景。
最短公共超序列（Shortest Common Supersequence, SCS）
最短公共超序列问题是寻找一个最短的序列，这个序列必须包含给定的两个序列作为其子序列。这个问题在多个领域中都非常重要，如在数据库整合、信息检索和生物信息学中合并多种生物序列。
应用背景
数据库整合：合并不同数据库中的数据时，SCS可以用来整合两个数据序列，确保所有信息都得到保存。
信息检索：在处理多个文档或数据源时，SCS可以帮助创建包含所有关键信息的综合视图。
生物信息学：在比较和合并来自不同物种的基因序列时，SCS提供了一种整合不同序列中信息的方法。
动态规划解法
解决最短公共超序列问题通常先求出两个序列的最长公共子序列（LCS），然后基于这个LCS构建超序列。
算法步骤
1. 计算LCS：
使用动态规划求解两个序列的LCS。设两个序列分别为 `X` 和 `Y`，创建一个 `(m+1) x (n+1)` 的二维数组 `dp`，其中 `m` 和 `n` 是两个序列的长度。
填充这个数组，其中 `dp[i][j]` 存储 `X[0...i-1]` 和 `Y[0...j-1]` 的LCS的长度。
2. 构建SCS：
根据动态规划表 `dp` 反向追踪来构建SCS。从 `dp[m][n]` 开始，向 `dp[0][0]` 方向追踪。
如果 `X[i-1] == Y[j-1]`，这个字符属于LCS，将其加入到SCS中，并同时向左和向上移动。
如果 `X[i-1] != Y[j-1]`，则选择 `dp[i-1][j]` 和 `dp[i][j-1]` 中较大的一个方向移动，同时将当前位置的非LCS字符添加到SCS中。
C++ 实现示例
#include <iostream>
#include <vector>
#include <string>
// 动态规划计算LCS
std::string findLCS(const std::string& X, const std::string& Y) {
int m = X.length(), n = Y.length();
std::vector<std::vector<int>> dp(m+1, std::vector<int>(n+1, 0));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (X[i-1] == Y[j-1])
dp[i][j] = dp[i-1][j-1] + 1;
else
dp[i][j] = std::max(dp[i-1][j], dp[i][j-1]);
}
}
// 构建LCS
std::string lcs;
int i = m, j = n;
while (i > 0 && j > 0) {
if (X[i-1] == Y[j-1]) {
lcs.push_back(X[i-1]);
i--;
j--;
} else if (dp[i-1][j] > dp[i][j-1]) {
i--;
} else {
j--;
}
}
reverse(lcs.begin(), lcs.end());
return lcs;
}
// 使用LCS构建SCS
std::string buildSCS(const std::string& X, const std::string& Y) {
std::string lcs = findLCS(X, Y);
std::string scs;
int i = 0, j = 0, k = 0;
while (k < lcs.length()) {
while (X[i] != lcs[k]) {
scs.push_back(X[i++]);
}
while (Y[j] != lcs[k]) {
scs.push_back(Y[j++]);
}
scs.push_back(lcs[k]);
i++; j++; k++;
}
scs += X.substr(i) + Y.substr(j);
return scs;
}
int main() {
std::string X = "AGGTAB";
std::string Y = "GXTXAYB";
std::string scs = buildSCS(X, Y);
std::cout << "Shortest Common Supersequence: " << scs << std::endl;
return 0;
}这个程序先计算两个字符串的LCS，然后使用这个LCS来构建SCS。通过确保LCS中的每个字符正确地合并进最终的SCS中，这个方法能够有效地生成包含所有必需子序列的最短超序列。
编辑距离与最长公共子序列（LCS）
编辑距离（通常指Levenshtein距离）是一种用于测量两个序列之间差异的度量方法，它通过计算从一个序列转换到另一个序列所需的最小编辑操作数（包括插入、删除和替换）来衡量序列之间的相似度或差异。LCS与编辑距离紧密相关，因为它们都关注于序列间的相似性和差异。
编辑距离与LCS的关系
编辑距离可以从LCS派生而来。对于两个给定的序列 X 和 Y：
LCS的长度：表示 X 和 Y 之间的最大相似性。
编辑距离：可以表示为 X 和 Y 的总长度减去两倍的LCS长度，即 D(X, Y) = |X| + |Y| - 2 * |LCS(X, Y)|。
这种计算方法基于这样一个事实：将序列 X 转换成 Y 的过程中，每个不在LCS中的字符都需要通过删除或插入操作来处理。
应用领域
1. 文本修订和校对：
在出版和文档管理系统中，编辑距离用于跟踪和显示文本修订的历史记录。这有助于作者和编辑理解文档从草稿到最终版本间的变化。
在校对工具中，编辑距离帮助确定文本间的最小变动，从而提出修正建议。
2. 语音识别系统：
在语音到文本转换技术中，编辑距离用于评估和改进语音识别算法的准确性。通过比较语音识别系统生成的文本与实际说话内容的转录，可以计算出系统的性能。
这种方法同样适用于自然语言处理（NLP），用于改善机器翻译和聊天机器人的响应质量。
3. DNA序列比较：
在生物信息学中，编辑距离是比较两个DNA序列差异的重要工具。通过计算不同物种或同一物种不同个体间DNA序列的编辑距离，科学家可以研究遗传差异和进化关系。
编辑距离也被用于病原体的变异分析，帮助识别疾病的传播模式和变异速率。
动态规划实现
计算编辑距离和LCS都可以通过动态规划实现。这里给出计算编辑距离的动态规划算法示例：
#include <iostream>
#include <vector>
#include <string>
int editDistance(const std::string& X, const std::string& Y) {
int m = X.size(), n = Y.size();
std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1));
for (int i = 0; i <= m; i++) dp[i][0] = i;
for (int j = 0; j <= n; j++) dp[0][j] = j;
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
if (X[i-1] == Y[j-1]) {
dp[i][j] = dp[i-1][j-1]; // No operation needed
} else {
dp[i][j] = std::min({dp[i-1][j-1] + 1, // Replace
dp[i][j-1] + 1,
// Insert
dp[i-1][j] + 1}); // Delete
}
}
}
return dp[m][n];
}
int main() {
std::string X = "kitten";
std::string Y = "sitting";
std::cout << "Edit Distance: " << editDistance(X, Y) << std::endl;
return 0;
}这段代码计算了将一个字符串转换为另一个字符串所需的最小编辑操作数。通过将这种方法应用于不同的应用领域，可以大大提高任务的效率和准确性。
结论
最长公共子序列问题是一个有广泛应用的经典问题。通过动态规划，我们不仅能有效解决问题，还能通过算法优化处理更大规模的数据。
扫一扫
28万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
