http://blog.csdn.net/steven30832/article/details/8259948

这个问题是动态规划算法中的一个经典问题，先看问题描述：

LCS:两个字符串 X和 Y，找到他们最长的公共子序列，该序列不要求是连续的。公共子序列的意思就是序列的相对顺序是不变的，但是序列不一定是连续的。

例如：

X = "BDCABA"

Y = "ABCBDAB"

他们的最长公共子序列是BCBA和BDAB，长度都为4，找到任意一个即可。

LCS问题也满足最优子结构：

定义  Xi 表示X的前I个字符组成的序列，同理得到Yj是Y的前j个字符组成的序列。

定义  z(i,j)表示Xi和Yj的最长公共子序列的长度LCS(Xi，Yj)

如此，可知：

我们要计算LCS(Xm,Yn)，则有如下情况：

1.X[m] = Y[n]，那么z(m,n) = LCS(Xm,Yn) = LCS(Xm-1,Yn-1) + 1

2.当X[m] != Y[n] ，那么z(m,n) 便是  LCS(Xm,Yn-1)和LCS(Xm-1,Yn)中较大者。

LCS也满足重叠子问题结构，计算LCS(Xm,Yn-1)和LCS(Xm-1,Yn)的时候也计算了LCS(Xm-1,Yn-1)。

因此，采用动态规划算法...

代码如下：

//	最长公共子序列 LCS 
//	Deng Chao
//	2012.12.4

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


//	计算LCS长度并记录LCS各个字符的前驱
//	z:保存前驱记录，用于得到公共子序列
//	return:	LCS长度
int LCS(const char *x , int xl, const char *y , int yl , char **&z)
{	
	//	构造动态规划的长度记录表
	//	z 是一个 (xl+1)*(yl+1)的矩阵
	int **c = new int*[xl+1];
	z = new char*[xl+1];
	for(int i = 0 ; i <= xl ; ++i)
	{
		c[i] = new int[yl+1];
		z[i] = new char[yl+1];
	}
	
	//	初始化，很重要！
	for(int i = 0 ; i <=xl; ++i)
	{
		c[i][0] = 0;
	}
	for(int i = 0 ; i <= yl ; ++i)
	{
		c[0][i] = 0;
	}
	
	//	从1开始填充表
	for(int i = 1 ; i <= xl ; ++i)
	{
		for(int j = 1 ; j <= yl ; ++j)
		{	
			if(x[i-1] == y[j-1])
			{
				//	当前值匹配
				c[i][j] = c[i-1][j-1] + 1;
				z[i][j] = 'm';	//表示此处匹配
			}
			else
			{
				if(c[i-1][j] > c[i][j-1])
				{
					c[i][j] = c[i-1][j];
					z[i][j] = 'u';	//向上
				}
				else
				{
					c[i][j] = c[i][j-1];
					z[i][j] = 'l';	//向左
				}
			}
			
			cout<<"c["<<i<<"]["<<j<<"] = "<<c[i][j]<<endl;
		}
	}
	
	int r = c[xl][yl];
	
	//	清空临时空间
	for(int i = 0 ; i <= xl ; ++i)
	{
		delete [] c[i];
	}
	delete [] c;
	
	return r;
}

//	打印序列
void Print_LCS(const char *x , const char *y , char **z , int xl , int yl)
{
	if(0 == xl || 0 == yl)
	{
		return;
	}
	
	if('m' == z[xl][yl])
	{
		Print_LCS(x , y , z , xl-1 , yl - 1);
		cout<<x[xl-1]<<" ";
	}
	else if('u' == z[xl][yl])
	{
		Print_LCS(x , y , z , xl-1 , yl);
	}
	else
	{
		Print_LCS(x, y , z , xl , yl-1);
	}
	
	return;
}


//	test
int main()
{
	const char *x = "BDCABA";
	const char *y = "ABCBDAB";
	int xl = strlen(x);
	int yl = strlen(y);
	
	char **z = NULL ;
	int len = LCS(x , xl , y , yl , z);
	cout<<"LCS_Length = "<<len<<endl;
	Print_LCS(x , y , z , xl , yl);
}

后记：

这里描述的是找到一个最长公共子序列，而在例子中也看到可能不止一个序列，因此，如果要找到所有的最长公共子序列，应该怎么处理？？？

思路：不采用记录前缀的矩阵z，而直接采用记录长度的矩阵c

如果c[i][j] = c[i-1][j-1] + 1，则对应的值是最长公共序列的，且可以通过c[i-1][j-1]递归回溯;

如果c[i][j] = c[i-1][j] ， 则该值不属于最长公共序列，但也可以通过c[i-1][j]进行回溯，c[i][j] = c[i-[j-1]的情况相同

如此可以回溯所有的可能路径，得到所有的最长公共序列。 

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

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

然后重新看一下这个问题，我们建立一个比较矩阵来比较两个字符串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)	//更新时从后往前遍历
		{ 
			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]<<" ";
	}
}