最长公共子序列问题　和　最长公共子串问题

问题描述：
最长公共子序列也称作最长公共子串(不要求连续)，英文缩写为LCS（Longest Common Subsequence）。其定义是，一个序列 S ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共子序列。

 

例如：X（A，B，C，B，D，A，B）

        Y(B，D，C，A，B，A)

 

那么最长公共子序列就是：B，C，B，A

算法设计：用动态规划方法解决

最长公共子序列的结构：

设X = { x1 , ... , xm },Y = { y1 , ... , yn }及它们的最长子序列Z = { z1 , ... , zk }则：

1、若 xm = yn ， 则 zk = xm = yn，且Z[k-1] 是 X[m-1] 和 Y[n-1] 的最长公共子序列

2、若 xm != yn ，且 zk != xm , 则 Z 是 X[m-1] 和 Y 的最长公共子序列

3、若 xm != yn , 且 zk != yn , 则 Z 是 Y[n-1] 和 X 的最长公共子序列

子问题的递归结构：

当 i = 0 , j = 0 时 , c[i][j] = 0

当 i , j > 0 ; xi = yi 时 , c[i][j] = c[i-1][j-1] + 1

当 i , j > 0 ; xi != yi 时 , c[i][j] = max { c[i][j-1] , c[i-1][j] }

 

还是以：X（A，B，C，B，D，A，B）

          Y(B，D，C，A，B，A)  为例

看下面的图：



由上面的分析：我们得到的源代码：

//最长公共子序列代码模板
#include <iostream>
using namespace std;
#define N 105

int dp[N+1][N+1];
char str1
,str2
;

//比较两个数的大小
int maxx(int a,int b){
if(a>b){
return a;
}
return b;
}

//函数功能：获取两个字符串的最长公共子序列的数目

//len1:字符串1的长度

//len2:字符串2的长度

int LCSL(int len1,int len2){
int i,j;
int len=maxx(len1,len2);
for(i=0;i<=len;i++){
dp[i][0]=0;//y为空字符串
dp[0][i]=0;//x为空字符串
}

for(i=1;i<=len1;i++){
for(j=1;j<=len2;j++){
if(str1[i-1]==str2[j-1]){
dp[i][j]=dp[i-1][j-1]+1;
}
else{
dp[i][j] = maxx(dp[i - 1][ j ] , dp[i][j - 1]) ;
}
}
}
return dp[len1][len2];
}

int main(){
while(cin>>str1>>str2){
int len1=strlen(str1);//获取字符串1的长度
int len2=strlen(str2);//获取字符串2的长度
cout<<LCSL(len1,len2)<<endl;
}
return 0;
}

动态规划有一个经典问题是最长公共子序列，但是这里的子序列不要求连续，如果要求序列是连续的，我们叫公共子串，那应该如何得到这个串呢？

　　最简单的方法就是依次比较，以某个串为母串，然后生成另一个串的所有长度的子串，依次去母串中比较查找，这里可以采用先从最长的子串开始，减少比较次数，但是复杂度依然很高！

　　然后重新看一下这个问题，我们建立一个比较矩阵来比较两个字符串str1和str2。

定义 lcs(i,j) ，当str1[i] = str2[j]时lcs(i,j)=1,否则等于0。

example:
str1 = "bab"
str2 = "caba"
建立矩阵
--b  a  b
c 0  0  0
a 0  1  0
b
1  0  1
a 0  1  0
　　连续i子串的特点就是如果str1[i]和str2[j]是属于某公共子串的最后一个字符，那么一定有str1[i]=str2[j] && str1[i-1] = str2[j-1]，从矩阵中直观的看，就是由“1”构成的“斜线”代表的序列都是公共子串，那么最长公共子串肯定就是斜线“1”最长的那个串。

　　那么现在问题就可以转化了，只要构造出如上的一个矩阵，用n^2的时间就可以得到矩阵，然后再到矩阵中去寻找最长的那个“1”构成的斜线就可以了！那么，现在又有了新的问题？如何快速的找到那个“1”构成的最长斜线呢？

　　采用DP的思想，如果str1[i] = str2[j]，那么此处的包含str1[i] 和 str2[j]公共子串的长度必然是包含str1[i-1]和str2[j-1]的公共子串的长度加1，那么现在我们可以重新定义lcs(i,j)，即是 lcs(i,j) = lcs(i-1,j-1) + 1，反之，lcs(i,j) = 0。那么上面的矩阵就变成了如下的样子：

--b  a  b

c 0  0  0

a 0  1  0

b
1  0  2

a 0  2  0

　　现在问题又变简单了，只需要花n^2的时间构造这样一个矩阵，再花n^2的时间去找到矩阵中最大的那个值，对应的就是最长公共子串的长度，而最大值对应的位置对应的字符，就是最长公共子串的最末字符。

　　算法还可以改进，我们可以将查找最大长度和对应字符的工作放在构造矩阵的过程中完成，一边构造一边记录当前的最大长度和对应位置，这样就节省了n^2的查找时间。

　　空间上也可以做改进，如果按照如上的方式构造，我们发现，当矩阵的第i+1行的值计算完成后，第i行的值就没有用了，即便是最长的长度出现在第i 行，我们也已经用变量记录下来了。因此，可以将矩阵缩减成一个向量来处理，向量的当前值对应第i行，向量的下一个循环后的值对应第i+1行。

// 最长公共子串（连续） LCS
// Deng Chao
// 2012.12.4

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

// 查找公共子串
// lcs记录公共子串
// return 公共子串长度
int LCS(const char *str1 , int len1 , const char *str2 , int len2 , char *&lcs)
{
if(NULL == str1 || NULL == str2)
{
return -1; //空参数
}

// 压缩后的最长子串记录向量
int *c = new int[len2+1];
for(int i = 0 ; i < len2 ; ++i)
{
c[i] = 0;
}
int max_len = 0; //匹配的长度
int pos = 0; //在str2上的匹配最末位置
for(int i = 0 ; i < len1 ; ++i)
{
for(int j = len2 ; j > 0 ; --j) //更新时从后往前遍历 ！！忽略了j=0的情况
{
if(str1[i] == str2[j-1])
{
c[j] = c[j-1] + 1;
if(c[j] > max_len)
{
max_len = c[j];
pos = j-1;
}
}
else
{
c[j] = 0;
}
}
}

if(0 == max_len)
{
delete [] c;
return 0;
}

// 得到公共子串
lcs = new char[max_len];
for(int i = 0 ; i < max_len ; ++i)
{
lcs[i] = str2[pos-max_len+1+i];
}
cout<<"pos = "<<pos<<endl;
delete [] c;
delete [] lcs;
return max_len;

}

// test
int main()
{
const char *str1 = "abacaba";
const char *str2 = "caba";
int len1 = strlen(str1);
int len2 = strlen(str2);

char *lcs;

int len = LCS(str1 , len1 , str2 , len2 , lcs);
cout<<"max length = "<<len<<endl;
for(int i = 0 ; i < len ; ++i)
{
cout<<lcs[i]<<" ";
}
}
　　该程序为原版转载程序，仍旧有错误，比如忽略了长度相同的情况和当j=0的情况：

C++转载版本

本文转载：http://www.cnblogs.com/LolaLiu/p/3981232.html

　　　　　http://www.cnblogs.com/-dante-/archive/2013/08/15/3260995.html