***************************************转载请注明出处：http://blog.csdn.net/lttree********************************************
第二章：动态规划
最长公共子序列
算法描述：
一个给定序列的子序列是该序列中删去若干元素后得到的序列。确切的说，若给定序列 X={ x1,x2,...,xm }，则另一序列 Z = { z1,z2, ... ,zk }，是X的子序列是指存在一个严格递增下标序列 { i1,i2, ... , ik } 使得对于所有
j = 1,2, ... ,k 有：zj = xij 。 例如，序列 Z = { B,C,D,B } 是序列 X = { A,B,C,B,D,A,B } 的子序列，相应的递增下标序列为 { 2,3,5,7 }。
给定两个序列 X 和 Y，当另一序列Z既是 X的子序列 又是 Y的子序列时，称Z是序列X和Y的 公共子序列。
最长公共子序列问题： 给定两个序列X和Y，找出X和Y的最长公共子序列。
算法分析：
>1< 传统方法
穷举搜索法是最容易想到的算法，对X的所有子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列。并且在检查过程中记录最长的公共子序列。X的所有子序列都检查过后即可求出X和Y的最长公共子序列。X的每个子序列相应于下标集 { 1,2,...,m }的一个子集。因此，共有 2^m 个不同子序列，从而穷举搜索法需要 指数时间。
>2< 动态规划
? 最长公共子序列问题有着最优子结构性质，
设 序列X = { x1,x2,...,xm } 和 Y={ y1,y2,...,yn } 的最长公共子序列为 Z={ z1,z2,...,zk } 则：
(1)若xm=yn,则zk=xm=yn,且zk-1是xm-1和yn-1的最长公共子序列.
(2)若xm!=yn且zk!=xm，则Z是xm-1和Y的最长公共子序列.
(3)若xm!=yn且zk!=yn，则Z是X和yn-1的最长公共子序列.
其中，Xm-1={x1,x2……xm-1}，Yn-1={y1,y2……yn-1},Zk-1={z1,z2……zk-1}.
? 最长公共子序列的子问题的递归结构
求两个序列的最长公共子序列，根据最优子结构性质可知，要按这样方式，递归进行：
> 当xm =
yn 时， 找出 Xm-1 和 Yn-1的最长公共子序列，然后在其尾部加上xm(或者yn）即可得
X和Y 的最长公共子序列。
> 当xm ≠
yn 时，必须解两个子问题，即找出 Xm-1 和 Y的一个最长公共子序列 及 X和 Yn-1 的一个最长公共子序列。 这两个公共子序列中较长者即为 X 和 Y 的最长公共子序列。
? 建立的递归关系如下：
算法程序：
<span style="font-family:Comic Sans MS;font-size:12px;">#include <iostream>
using namespace std;
const int M = 7;
const int N = 6;
// 求最长公共子序列函数
void LCSLength( int m , int n ,char* x ,char* y,int** c,int** b)
{
int i,j;
// 数组边界设置为0
for( i = 1 ; i <= m ; ++i ) c[i][0] = 0;
for( i = 1 ; i <= n ; ++i ) c[0][i] = 0;
// 挨个比较
for( i = 1 ; i <= m ; ++i )
for( j = 1 ; j <= n ; ++j ) {
// 如果 相应位置 字符相等，则最长子序列在之前的基础上+1，并且b数组存储标记1
if( x[i] == y[j] ) {
c[i][j] = c[i-1][j-1] + 1;
b[i][j] = 1;
}
// 如果 相应位置 字符不同，则查询横向和纵向哪个子序列长度最长，并且b数组存储相应标记
else if( c[i-1][j] >= c[i][j-1] ) {
c[i][j] = c[i-1][j];
b[i][j] = 2;
}
else {
c[i][j] = c[i][j-1];
b[i][j] = 3;
}
}
}
// 输出函数
void output(char *s,int n)
{
for(int i=1; i<=n; i++)
{
cout<<s[i]<<" ";
}
cout<<endl;
}
// 输出最长公共子序列函数
void LCS( int i ,int j ,char* x,int** b )
{
if( i == 0 || j == 0 ) return;
if( b[i][j] == 1 ) {
LCS(i-1,j-1,x,b);
cout<<x[i];
}
else if( b[i][j] == 2 )
LCS(i-1,j,x,b);
else
LCS(i,j-1,x,b);
}
int main()
{
char x[] = {' ','A','B','C','B','D','A','B'};
char y[] = {' ','B','D','C','A','B','A'};
int **c = new int *[M+1];
int **b = new int *[M+1];
for(int i=0;i<=M;i++)
{
c[i] = new int[N+1];
b[i] = new int[N+1];
}
cout<<"序列X："<<endl;
output(x,M);
cout<<"序列Y："<<endl;
output(y,N);
LCSLength(M,N,x,y,c,b);
cout<<"序列X、Y最长公共子序列长度为："<<c[M][N]<<endl;
cout<<"序列X、Y最长公共子序列为："<<endl;
LCS(M,N,x,b);
cout<<endl;
return 0;
}</span>
程序所构造的数组为：
算法优化：
对于一个具体问题，按照一般的算法设计策略设计出的算法，往往在算法的时间和空间需求上还可以改进。这种改进，通常是利用具体问题的一些特殊性。
例如，在算法LCS_length和LCS中，可进一步将数组b省去。
事实上，数组元素c[i,j]的值仅由c[i-1][j-1]，c[i-1][j]和c[i][j-1]三个值之一确定，而数组元素b[i][j]也只是用来指示c[i][j]究竟由哪个值确定。
因此，在算法LCS中，我们可以不借助于数组b而借助于数组c本身临时判断c[i][j]的值是由c[i-1][j-1]，c[i-1][j]和c[i][j-1]中哪一个数值元素所确定，代价是Ο(1)时间。
既然b对于算法LCS不是必要的，那么算法LCS_length便不必保存它。这一来，可节省θ(mn)的空间，而LCS_length和LCS所需要的时间分别仍然是Ο(mn)和Ο(m+n)。
另外，如果只需要计算最长公共子序列的长度，则算法的空间需求还可大大减少。事实上，在计算c[i][j]时，只用到数组c的第i行和第i-1行。因此，只要用2行的数组空间就可以计算出最长公共子序列的长度。更进一步的分析还可将空间需求减至min(m, n)。
***************************************转载请注明出处：http://blog.csdn.net/lttree********************************************