动态规划算法求解最长公共子序列-编程知识

动态规划算法是运筹学中求解多阶段决策问题的经典算法，本文将介绍动态规划算法的基本思想，并介绍如何使用动态规划算法求解最长公共子序列问题。

1. 动态规划算法的基本思想

动态规划算法本质也是基于分治思想，将待求解问题分解成若干个子问题。但是传统的分治法经分解得到的子问题往往不是相互独立的，因此在分治法求解的过程中有些子问题会被重复计算多次，这种冗余计算使得算法的时间复杂度增大。

那么我们很自然地会想到，可以用空间换时间，如果 把已解决的子问题的答案保存在表格中，再次需要时从表格中查找已经求解的答案，就可以避免大量的重复计算 ，这就是动态规划算法。

下面我们通过最长公共子序列问题的求解，进一步了解动态规划算法在实际应用中如何实现。

2. 最长公共子序列（LCS）问题

2.1 子序列定义

给定序列 $X=\{x_1, x_2, … ,x_m\}$ ，若序列 $Z=\{z_1, z_2, …, z_k\}$ 是 $X$ 的子序列，则存在一个严格递增下标序列 ${i_1, i_2, …, i_k\}$ ，使得对于所有 $j = 1, 2, \dots, k$ ，有 $z_j={x_i}_{j}$ 。

例如：序列 $Z=\{B，C，D，A\}$ 是序列 $X=\{A，B，C，B，D，A，B\}$ 的子序列，相应的递增下标序列为 ${2，3，5，6\}$ 。

给定2个序列 $X=\{x_1, x_2, … ,x_m\}$ 和 $Y=\{y_1, y_2, … ,y_n\}$ ，若另一序列 $Z$ 既是 $X$ 的子序列又是 $Y$ 的子序列，则称 $Z$ 是序列 $X$ 和 $Y$ 的公共子序列，最大长度的 $Z$ 即为 $X$ 和 $Y$ 的最长公共子序列（LCS）。

2.2 LCS的子问题与数据结构设计

求 $X$ 和 $Y$ 的LCS可分解为2种情况：

如果 $x_m=y_n$ ，那么求 $X_{m-1}$ 和 $Y_{n-1}$ 的LCS。
如果 $x_m \neq y_n$ ，那么求 $X_{m-1}$ 和 $Y$ 的LCS，求 $X$ 和 $Y_{n-1}$ 的LCS，取两者中的最大的。

因此，将c[i, j]定义为 $X_i$ 和 $Y_j$ 的LCS长度， $\sim m$ ， $\sim n$ ：

$c[i][j]=\left\{\begin{matrix} 0 & i=0,j=0 \\ c[i-1][j-1] + 1 & i,j>0;x_i=y_j \\ \max{c[i][j-1], c[i-1][j]} & i,j>0;x_i \neq y_j \end{matrix}\right.$

3. 程序代码

下面我们用C++对上述递归式进行代码实现，首先使用lcs.cpp找出一个LCS，在此基础上再扩展到lcs_all.cpp找出全部LCS。

3.1 lcs.cpp（找出一个LCS）

lcs.cpp按照《算法导论》一书上的伪代码改编而成，在书中伪代码的基础上，实现了不用表b，只用表c来完成找出最大公共子序列的任务。因为每个c[i][j]只依赖于c[i−1][j]、c[i][j−1]、c[i−1][j−1]三项，当给定c[i][j]时，我们可以在 $O (1)$ 的时间内判定出c[i][j]是使用了三项中的哪一项。从而节约了 $\Theta(mn)$ 的空间。需要注意的是：如果两个字符串存在多个LCS时，按照书中伪代码实现的lcs.cpp只能输出其中一个LCS。

//动态规划求解并输出其中一个LCS 
#include <iostream>
#include <string>using namespace std;int max(int a, int b) {  //返回a，b中值较大的元素 return (a > b) ? a : b;
}int lcs_length(string sx, string sy, int **c) { //动态规划计算LCS的长度int xlen = sx.length();int ylen = sy.length();//c[i][j]记录sx[i]与sy[j]的LCS的长度  for (int i = 0; i < xlen + 1; i++) {for (int j = 0; j < ylen + 1; j++) {if (i == 0 || j == 0) {             //情形1：i = 0或j = 0; c[i][j] = 0;}else if (sx[i - 1] == sy[j - 1]) { //情形2：i, j > 0且sx[i-1] = sy[j-1] c[i][j] = c[i - 1][j - 1] + 1;	}else {                             //情形3：i, j > 0且sx[i-1] != sy[j-1] c[i][j] = max(c[i][j - 1], c[i - 1][j]);}}}return c[xlen][ylen];
}void print_lcs(int **c, string sx, int i, int j, string &s) { //递归将sx与sy的一个LCS赋值给字符串s if (i == 0 || j == 0) {             //对应lcs_length()中的情形1 return;}	if (c[i][j] == c[i - 1][j]) {       //对应lcs_length()中的情形3 print_lcs(c, sx, i - 1, j, s);}else if (c[i][j] == c[i][j - 1]) {  //对应lcs_length()中的情形3  print_lcs(c, sx, i, j - 1, s);}else {                              //对应lcs_length()中的情形2 print_lcs(c, sx, i - 1, j - 1, s);s += sx[i - 1];}
}int main() {string sx, sy;cout << "Please enter the string x and the string y:" << endl;cout << "sx: ";cin >> sx;cout << "sy: ";cin >> sy;int xlen = sx.length();int ylen = sy.length();int **c = new int *[xlen + 1];     //为动态规划表开空间 for (int i = 0; i < xlen + 1; i++) {c[i] = new int [ylen + 1];}int maxlen = lcs_length(sx, sy, c);cout << "The length of LCS is " << maxlen << endl;string s;print_lcs(c, sx, xlen, ylen, s);cout << "The LCS of sx and sy is: " << s << endl;for (int i = 0; i < xlen + 1; i++) { //释放占用的空间 delete[]c[i];}delete[]c;return 0;
}

3.2 lcs_all.cpp（找出全部LCS）

为了输出全部的LCS，我对lcs.cpp中的print_lcs函数进行了改进，改进后的代码见lcs_all.cpp。在lcs_all.cpp中，我从动态规划表右下角开始回溯，直到到达表的上边界或左边界停止。若sx[i-1]=sy[j-1]，则把这个字符放入最长公共子序列中；若sx[i-1] != sy[j-1]，则比较c[i-1][j]和c[i][j-1]的值，跳入值较大的继续进行判断；若c[i-1][j] == c[i][j-1]，说明最长公共子序列有多个，两边都要进行回溯。最后将所有的LCS都保存在set中。需要注意的是：当字符串过长时，由于回溯范围过广，输出全部的LCS耗时很长。

//动态规划求解并输出所有的LCS
#include <iostream>
#include <string>
#include <set>using namespace std;set<string> lcsSet;      //将所有的lcs保存在set中 int max(int a, int b) {  //返回a，b中值较大的元素 return (a > b) ? a : b;
}int lcs_length(string sx, string sy, int **c) { //动态规划计算LCS的长度int xlen = sx.length();int ylen = sy.length();//c[i][j]记录sx[i]与sy[j]的LCS的长度  for (int i = 0; i < xlen + 1; i++) {for (int j = 0; j < ylen + 1; j++) {if (i == 0 || j == 0) {             //情形1：i = 0或j = 0; c[i][j] = 0;}else if (sx[i - 1] == sy[j - 1]) { //情形2：i, j > 0且sx[i-1] = sy[j-1] c[i][j] = c[i - 1][j - 1] + 1;	}else {                             //情形3：i, j > 0且sx[i-1] != sy[j-1] c[i][j] = max(c[i][j - 1], c[i - 1][j]);}}}return c[xlen][ylen];
}string reverse(string s) { //将字符串s逆序 int low = 0;int high = s.length() - 1;while (low < high) {  char temp = s[low]; //交换字符串最低位和最高位 s[low] = s[high];s[high] = temp;low++;high--;}return s;
} void print_lcs(int **c, string sx, string sy, int i, int j, string s) { //根据动态规划表回溯 while (i > 0 && j > 0) {      //从动态规划表最右下角开始回溯，直至到达i或j小于等于0为止 if (sx[i - 1] == sy[j - 1]) { //若sx[i-1] == sy[j-1]，则把这个字符放入LCS中s += sx[i - 1];i--;j--;}else {  //若sx[i-1] != sy[j-1]，则比较c[i-1][j]和c[i][j-1]的值，跳入值较大的继续进行判断if (c[i - 1][j] > c[i][j - 1]) { i--;}else if (c[i - 1][j] < c[i][j - 1]) {j--;}	else {  //若c[i-1][j] == c[i][j-1]，说明最长公共子序列有多个，两边都要进行回溯print_lcs(c, sx, sy, i-1, j, s);print_lcs(c, sx, sy, i, j-1, s);return;}}}lcsSet.insert(reverse(s)); //将字符串s逆序放入集合lcsSet中 
}int main() {string sx, sy;cout << "Please enter the string x and the string y:" << endl;cout << "sx: ";cin >> sx;cout << "sy: ";cin >> sy;int xlen = sx.length();int ylen = sy.length();int **c = new int *[xlen + 1];     //为动态规划表开空间 for (int i = 0; i < xlen + 1; i++) {c[i] = new int [ylen + 1];}int maxlen = lcs_length(sx, sy, c);cout << "The length of LCS is " << maxlen << endl;string s;print_lcs(c, sx, sy, xlen, ylen, s);cout << "The LCS of sx and sy is: " << endl;set<string>::iterator iter = lcsSet.begin();for (; iter != lcsSet.end(); iter++) {cout << *iter << endl;}for (int i = 0; i < xlen + 1; i++) { //释放占用的空间 delete[]c[i];}delete[]c;return 0;
}

4. 运行结果

使用lcs.cpp与lcs_all.cpp时，用户需输入字符串sx和字符串sy，按下回车键，程序会输出sx和sy的LCS的长度以及LCS字符串。

4.1 lcs.cpp

sx：ABCBDAB
sy：BDCABA
lcs：BCBA（长度为4）

sx：1A2C3D4B56
sy：B1D23CA45B6A
lcs：12C4B6（长度为6）
sx：aabbbbeeeeeeeeeeddddddkktylmnqqqqqqtiunmsfg
sy：abeffffffffttttttkkkkddddddrsunnspqtrmma
lcs：abeddddddnqtm（长度为13）