动态规划---LCS问题 最长公共子序列

今天看到个帖子，原文如下

想要求出两个串的最长公共子序列（不是子串，子序列可以是不连续的），以下的这个算法（用的是lcs，动态规划）能求出一个最长公共子序列，是badb，长度是4.可是这两个串bacdbd 和dbcbadb的最长公共子序列有三个，分别是badb，bcbd，bcdb，长度都是4，如何把它们都求出来？

Java code
import java.io. * ;
public class ys { static int length = 0 ; // 保存最长公共子序列的长度
    static String  str_same = "" ;  // 保存最长公共子序列
    static int k = 0 ;
    public static void main(String args[])
    {
        char x[],y[];
        String str_x = " bacdbd " ,str_y = " dbcbadb " ; // 原始比较的两个串
        try {
            str_x = " " + str_x;       
            str_y = " " + str_y;
        } catch (Exception e){
            e.printStackTrace();
        }
        x = str_x.toCharArray();
        y = str_y.toCharArray();
        int b[][] = new int [x.length][y.length]; lcsLength(x,y,b); lcs(x.length - 1 ,y.length - 1 ,x,b);
        System.out.println( " length: " + length);
        System.out.println( " str_same: " + str_same);
        System.out.print( " /n " );
    }
    public   static void lcsLength( char []x, char []y, int [][]b)
    {
        int xMaxIndex = x.length - 1 ;
        int yMaxIndex = y.length - 1 ;
        int count[][] = new int [xMaxIndex + 1 ][yMaxIndex + 1 ];
        for ( int i = 0 ;i <= xMaxIndex;i ++ )
        {
            count[i][ 1 ] = 0 ;
        }
        for ( int i = 0 ;i <= yMaxIndex;i ++ )
        {
            count[ 0 ][i] = 0 ;
        }
        for ( int i = 1 ;i <= xMaxIndex;i ++ )
        for ( int j = 1 ;j <= yMaxIndex;j ++ )
        {
            if (x[i] == y[j]) // 如果相等 则对角线加一
            {
                count[i][j] = count[i - 1 ][j - 1 ] + 1 ;
                b[i][j] = 1 ;
            }
            // 如果不等,则比较上方和左方,取最大值
            else if (count[i - 1 ][j] >= count[i][j - 1 ])
            {
                count[i][j] = count[i - 1 ][j];
                b[i][j] = 2 ;
            }
            else
            {
                count[i][j] = count[i][j - 1 ];
                b[i][j] = 3 ;
            }
           
        }
    }
    public static void lcs( int i, int j, char []x, int [][]b)
    {
        if (i == 0 || j == 0 )
        {
            return ;
        }
        if (b[i][j] == 1 )
        {
            length ++ ;          
            lcs(i - 1 ,j - 1 ,x,b);
            str_same += x[i];
        }
        else if (b[i][j] == 2 )
        {
           
            lcs(i - 1 ,j,x,b);
           
        }
        else if (b[i][j] == 3 )
        {
            lcs(i,j - 1 ,x,b);
        }
    }
}

分析后解答如下

import java.io.*;
public class Ys
{
    static int length = 0; //保存最长公共子序列的长度
    static int maxLength = 0;//记录最长子序列长度
    static int count = 0;
    
    static int k = 0;
    public static void main(String args[])
    {
     String  str_same = "";  //保存最长公共子序列
        char x[],y[];
        String str_x="bacdbd",str_y="dbcbadb"; //原始比较的两个串
        try{
            str_x=" "+str_x;        
            str_y=" "+str_y;
        } catch(Exception e){
            e.printStackTrace();
        }
        x=str_x.toCharArray();
        y=str_y.toCharArray();
        int b[][]=new int[x.length][y.length];
        lcsLength(x,y,b);
        lcs(x.length-1,y.length-1,x,b,"");
    }
    public  static void lcsLength(char []x,char []y,int [][]b)
    {
        int xMaxIndex=x.length-1;
        int yMaxIndex=y.length-1;
        int count[][]=new int[xMaxIndex+1][yMaxIndex+1];
        for(int i=0;i <=xMaxIndex;i++)
        {
            count[i][1]=0;
        }
        for(int i=0;i <=yMaxIndex;i++)
        {
            count[0][i]=0;
        }
        for(int i=1;i <=xMaxIndex;i++)
        for(int j=1;j <=yMaxIndex;j++)
        {
            if(x[i]==y[j]) //如果相等 则对角线加一
            {
                count[i][j]=count[i-1][j-1]+1;
                maxLength = Math.max(maxLength,count[i][j]);
                b[i][j]=1;
            }
            //如果不等,则比较上方和左方,取最大值
            else if(count[i-1][j]>count[i][j-1]) 
            {
                count[i][j]=count[i-1][j];
                maxLength = Math.max(maxLength,count[i][j]);
                b[i][j]=2;
            }

else if (count[i-1][j]             {

                count[i][j]=count[i][j-1];
                maxLength = Math.max(maxLength,count[i][j]);
                b[i][j]=3;
             
             }
            else 
            {

                count[i][j]=count[i-1][j];
                maxLength = Math.max(maxLength,count[i][j]);
                b[i][j]=4; 

            }

        }
    }
    public static void lcs(int i,int j,char []x,int [][]b,String strResult)
    {
        if(i==0 ¦ ¦j==0)
        {
            return;
        }
        if(b[i][j]==1)
        {
         strResult = x[i] + strResult;
         if (strResult.length() == maxLength) {
         System.out.println(strResult.length());
         System.out.println(strResult);
         }

            length ++;           
            lcs(i-1,j-1,x,b,strResult);

        }
        else if(b[i][j]==2)
        {
            
            lcs(i-1,j,x,b,strResult);
            
        }
        else if(b[i][j]==3)
        {
            lcs(i,j-1,x,b,strResult);
        }
        else if(b[i][j]==4)
        {
            lcs(i-1,j,x,b,strResult);
            lcs(i,j-1,x,b,strResult);
        }     

}
}

// 次程序仍有问题，时间复杂度太大，有待改进

查阅相关知识如下：

问题描述
一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说，若给定序列X=，则另一序列Z=是X的子序列是指存在一个严格递增的下标序列 ，使得对于所有j=1,2,…,k 有Xij=Zj;
例如，序列Z=是序列X=的子序列，相应的递增下标序列为<2,3,5,7>。

给定两个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列。例如，若X=和Y=，则序列是X和Y的一个公共子序列，序列也是X和Y的一个公共子序列。而且，后者是X和Y的一个最长公共子序列，因为X和Y没有长度大于4的公共子序列。
最长公共子序列(LCS)问题：给定两个序列X=和Y=，要求找出X和Y的一个最长公共子序列。

最长公共子序列问题LCS
问题描述
参考解答
动态规划算法可有效地解此问题。下面我们按照动态规划算法设计的各个步骤来设计一个解此问题的有效算法。

1.最长公共子序列的结构
解最长公共子序列问题时最容易想到的算法是穷举搜索法，即对X的每一个子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列，并且在检查过程中选出最长的公共子序列。X的所有子序列都检查过后即可求出X和Y的最长公共子序列。X的一个子序列相应于下标序列{1, 2, …, m}的一个子序列，因此，X共有2m个不同子序列，从而穷举搜索法需要指数时间。

事实上，最长公共子序列问题也有最优子结构性质，因为我们有如下定理：

定理: LCS的最优子结构性质

设序列X=和Y=的一个最长公共子序列Z=，则：

若xm=yn，则zk=xm=yn且Zk-1是Xm-1和Yn-1的最长公共子序列；
若xm≠yn且zk≠xm ，则Z是Xm-1和Y的最长公共子序列；
若xm≠yn且zk≠yn ，则Z是X和Yn-1的最长公共子序列。
其中Xm-1=，Yn-1=，Zk-1=。

证明

用反证法。若zk≠xm，则是X和Y的长度为k十1的公共子序列。这与Z是X和Y的一个最长公共子序列矛盾。因此，必有zk=xm=yn。由此可知Zk-1是Xm-1和Yn-1的一个长度为k-1的公共子序列。若Xm-1和Yn-1有一个长度大于k-1的公共子序列W，则将xm加在其尾部将产生X和Y的一个长度大于k的公共子序列。此为矛盾。故Zk-1是Xm-1和Yn-1的一个最长公共子序列。
由于zk≠xm，Z是Xm-1和Y的一个公共子序列。若Xm-1和Y有一个长度大于k的公共子序列W，则W也是X和Y的一个长度大于k的公共子序列。这与Z是X和Y的一个最长公共子序列矛盾。由此即知Z是Xm-1和Y的一个最长公共子序列。
与 2.类似。
这个定理告诉我们，两个序列的最长公共子序列包含了这两个序列的前缀的最长公共子序列。因此，最长公共子序列问题具有最优子结构性质。

2.子问题的递归结构
由最长公共子序列问题的最优子结构性质可知，要找出X=和Y=的最长公共子序列，可按以下方式递归地进行：当xm=yn时，找出Xm-1和Yn-1的最长公共子序列，然后在其尾部加上xm(=yn)即可得X和Y的一个最长公共子序列。当xm≠yn时，必须解两个子问题，即找出Xm-1和Y的一个最长公共子序列及X和Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的一个最长公共子序列。

由此递归结构容易看到最长公共子序列问题具有子问题重叠性质。例如，在计算X和Y的最长公共子序列时，可能要计算出X和Yn-1及Xm-1和Y的最长公共子序列。而这两个子问题都包含一个公共子问题，即计算Xm-1和Yn-1的最长公共子序列。

与矩阵连乘积最优计算次序问题类似，我们来建立子问题的最优值的递归关系。用c[i,j]记录序列Xi和Yj的最长公共子序列的长度。其中Xi=，Yj=。当i=0或j=0时，空序列是Xi和Yj的最长公共子序列，故c[i,j]=0。其他情况下，由定理可建立递归关系如下：

3.计算最优值
直接利用(2.2)式容易写出一个计算c[i,j]的递归算法，但其计算时间是随输入长度指数增长的。由于在所考虑的子问题空间中，总共只有θ(m*n)个不同的子问题，因此，用动态规划算法自底向上地计算最优值能提高算法的效率。

计算最长公共子序列长度的动态规划算法LCS_LENGTH(X,Y)以序列X=和Y=作为输入。输出两个数组c[0..m ,0..n]和b[1..m ,1..n]。其中c[i,j]存储Xi与Yj的最长公共子序列的长度，b[i,j]记录指示c[i,j]的值是由哪一个子问题的解达到的，这在构造最长公共子序列时要用到。最后，X和Y的最长公共子序列的长度记录于c[m,n]中。

Procedure LCS_LENGTH(X,Y);begin m:=length[X]; n:=length[Y]; for i:=1 to m do c[i,j]:=0; for j:=1 to n do c[0,j]:=0; for i:=1 to m do for j:=1 to n do if x[i]=y[j] then begin c[i,j]:=c[i-1,j-1]+1; b[i,j]:="↖"; end else if c[i-1,j]≥c[i,j-1] then begin c[i,j]:=c[i-1,j]; b[i,j]:="↑"; end else begin c[i,j]:=c[i,j-1]; b[i,j]:="←" end; return(c,b);end;
由于每个数组单元的计算耗费Ο(1)时间，算法LCS_LENGTH耗时Ο(mn)。

4.构造最长公共子序列
由算法LCS_LENGTH计算得到的数组b可用于快速构造序列X=和Y=的最长公共子序列。首先从b[m,n]开始，沿着其中的箭头所指的方向在数组b中搜索。当b[i,j]中遇到"↖"时，表示Xi与Yj的最长公共子序列是由Xi-1与Yj-1的最长公共子序列在尾部加上xi得到的子序列；当b[i,j]中遇到"↑"时，表示Xi与Yj的最长公共子序列和Xi-1与Yj的最长公共子序列相同；当b[i,j]中遇到"←"时，表示Xi与Yj的最长公共子序列和Xi与Yj-1的最长公共子序列相同。

下面的算法LCS(b,X,i,j)实现根据b的内容打印出Xi与Yj的最长公共子序列。通过算法的调用LCS(b,X,length[X],length[Y])，便可打印出序列X和Y的最长公共子序列。

Procedure LCS(b,X,i,j);begin if i=0 or j=0 then return; if b[i,j]="↖" then begin LCS(b,X,i-1,j-1); print(x[i]); {打印x[i]} end else if b[i,j]="↑" then LCS(b,X,i-1,j)
else LCS(b,X,i,j-1);end;
在算法LCS中，每一次的递归调用使i或j减1，因此算法的计算时间为O(m+n)。

例如，设所给的两个序列为X=和Y=。由算法LCS_LENGTH和LCS计算出的结果如图2所示。

　

j 0 1 2 3 4 5 6
i yj B D C A B A
┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
0 xi │ 0 0 0 0 0 0 │
│ ↑ ↑ ↑ ↖ ↖ │
1 A │ 0 0 0 0 1 ← 1 1 │
│ ↖ ↑ ↖ │
2 B │ 0 1 ← 1 ← 1 1 2 ← 2 │
│ ↑ ↑ ↖ ↑ ↑ │
3 C │ 0 1 1 2 ← 2 2 2 │
│ ↖ ↑ ↑ ↑ ↖ │
4 B │ 0 1 1 2 2 3 ← 3 │
│ ↑ ↖ ↑ ↑ ↑ ↑ │
5 D │ 0 1 2 2 2 3 3 │
│ ↑ ↑ ↑ ↖ ↑ ↖ │
6 A │ 0 1 2 2 3 3 4 │
│ ↖ ↑ ↑ ↑ ↖ ↑ │
7 B │ 0 1 2 2 3 4 5 │
└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
图2 算法LCS的计算结果

5.算法的改进
对于一个具体问题，按照一般的算法设计策略设计出的算法，往往在算法的时间和空间需求上还可以改进。这种改进，通常是利用具体问题的一些特殊性。

例如，在算法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仍需要Ο(mn)的空间，因此这里所作的改进，只是在空间复杂性的常数因子上的改进。

另外，如果只需要计算最长公共子序列的长度，则算法的空间需求还可大大减少。事实上，在计算c[i,j]时，只用到数组c的第i行和第i-1行。因此，只要用2行的数组空间就可以计算出最长公共子序列的长度。更进一步的分析还可将空间需求减至min(m, n)。

以上内容引用自： http://blog.sina.com.cn/s/blog_48969478010007hn.html