算法重拾之路——最长公共子序列(LCS)

***************************************转载请注明出处：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********************************************