动态规划之最长公共子序列（LCS）

一：最长公共子序列（Longest Common Subsequence, LCS）概念

     举个例子，cnblogs这个字符串中子序列有多少个呢？很显然有2⁷个，比如其中的cb,cgs等等都是其子序列，一个字符串Str，去掉零个或者多个元素所剩下的子串称为Str的子序列，我们可以看出，子序列不见得一定是连续的，连续的那是子串。

     我想大家已经了解了子序列的概念，那现在可以延伸到两个字符串了，那么大家能够看出：cnblogs和belong的公共子序列吗？

在你找出的公共子序列中，你能找出最长的公共子序列吗？

从图中我们看到了最长公共子序列为blog，仔细想想我们可以发现其实最长公共子序列的个数不是唯一的，可能会有两个以上，

但是长度一定是唯一的，比如这里的最长公共子序列的长度为4

寻找LCS的一种方法是枚举X所有的子序列，然后注意检查是否是Y的子序列，并随时记录发现的最长子序列。假设X有m个元素，则X有2^m个子序列，指数级的时间，对长序列不实际。

使用动态规划求解这个问题，先寻找最优子结构。设X=<x₁,x₂,…,x_m>和Y=<y₁,y₂,…,y_n>为两个序列，LCS(X,Y)表示X和Y的一个最长公共子序列，可以看出

1. 如果x_m=y_n，则LCS ( X,Y ) = x_m + LCS ( X_m-1,Y_n-1 )。
2. 如果x_m!=y_n，则LCS( X,Y )= max{ LCS ( X_m-1, Y ), LCS ( X, Y_n-1 ) }

LCS问题也具有重叠子问题性质：为找出X和Y的一个LCS，可能需要找X和Y_n-1的一个LCS以及X_m-1和Y的一个LCS。但这两个子问题都包含着找X_m-1和Y_n-1的一个LCS，等等.

DP最终处理的还是数值（极值做最优解），找到了最优值，就找到了最优方案；为了找到最长的LCS，我们定义dp[i][j]记录序列LCS的长度，合法状态的初始值为当序列X的长度为0或Y的长度为0，公共子序列LCS长度为0，即dp[i][j]=0，所以用i和j分别表示序列X的长度和序列Y的长度，状态转移方程为

1. dp[i][j] = 0  如果i=0或j=0
2. dp[i][j] = dp[i-1][j-1] + 1  如果X[i-1] = Y[i-1]
3. dp[i][j] = max{ dp[i-1][j], dp[i][j-1] }  如果X[i-1] != Y[i-1]

二、动态规划法

经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。

为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有用，把所有子问题的解存于该数组中，这就是动态规划法所采用的基本方法。

【问题】 求两字符序列的最长公共字符子序列

问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列<i0，i1，…，ik-1>，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。

考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：

（1） 如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；

（2） 如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；

（3） 如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。

这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

回溯输出最长公共子序列过程：

感觉这个代码比较好理解，第一个是求最大公共子序列的长度，第二个是输出公共子序列

#include <iostream>using namespace std; /* LCS * 设序列长度都不超过20*/ int dp[21][21]; /* 存储LCS长度, 下标i,j表示序列X,Y长度 */char X[21];char Y[21];int i, j; void main(){    cin.getline(X,20);    cin.getline(Y,20);     int xlen = strlen(X);    int ylen = strlen(Y);     /* dp[0-xlen][0] & dp[0][0-ylen] 都已初始化0 */    for(i = 1; i <= xlen; ++i)    {        for(j = 1; j <= ylen; ++j)        {            if(X[i-1] == Y[j-1])            {                dp[i][j] = dp[i-1][j-1] + 1;            }else if(dp[i][j-1] > dp[i-1][j])            {                dp[i][j] = dp[i][j-1];            }else            {                dp[i][j] = dp[i-1][j];            }        }    }    printf("len of LCS is: %d\n", dp[xlen][ylen]);     /* 输出LCS 本来是逆序打印的，可以写一递归函数完成正序打印       这里采用的方法是将Y作为临时存储LCS的数组，最后输出Y    */i = xlen;j = ylen;int k = dp[i][j];char lcs[21] = {'\0'};while(i && j){    if(X[i-1] == Y[j-1] && dp[i][j] == dp[i-1][j-1] + 1)    {        lcs[--k] = X[i-1];        --i; --j;    }else if(X[i-1] != Y[j-1] && dp[i-1][j] > dp[i][j-1])    {        --i;    }else    {        --j;    }}printf("%s\n",lcs);

（2）另一种思路

/**  找出两个字符串的最长公共子序列的长度 ** author :liuzhiwei   ** data   :2011-08-15 **/   #include "stdio.h"  #include "string.h"  #include "stdlib.h"  int LCSLength(char* str1, char* str2, int **b)  {      int i,j,length1,length2,len;      length1 = strlen(str1);      length2 = strlen(str2);        //双指针的方法申请动态二维数组      int **c = new int*[length1+1];      //共有length1+1行      for(i = 0; i < length1+1; i++)          c[i] = new int[length2+1];      //共有length2+1列        for(i = 0; i < length1+1; i++)          c[i][0]=0;        //第0列都初始化为0      for(j = 0; j < length2+1; j++)          c[0][j]=0;        //第0行都初始化为0        for(i = 1; i < length1+1; i++)      {          for(j = 1; j < length2+1; j++)          {              if(str1[i-1]==str2[j-1])   //由于c[][]的0行0列没有使用，c[][]的第i行元素对应str1的第i-1个元素              {                  c[i][j]=c[i-1][j-1]+1;                  b[i][j]=0;          //输出公共子串时的搜索方向              }              else if(c[i-1][j]>c[i][j-1])              {                  c[i][j]=c[i-1][j];                  b[i][j]=1;              }              else              {                  c[i][j]=c[i][j-1];                  b[i][j]=-1;              }          }      }      /*     for(i= 0; i < length1+1; i++)     {     for(j = 0; j < length2+1; j++)     printf("%d ",c[i][j]);     printf("\n");     }     */      len=c[length1][length2];      for(i = 0; i < length1+1; i++)    //释放动态申请的二维数组          delete[] c[i];      delete[] c;      return len;  }  void PrintLCS(int **b, char *str1, int i, int j)  {      if(i==0 || j==0)          return ;      if(b[i][j]==0)      {          PrintLCS(b, str1, i-1, j-1);   //从后面开始递归，所以要先递归到子串的前面，然后从前往后开始输出子串          printf("%c",str1[i-1]);        //c[][]的第i行元素对应str1的第i-1个元素      }      else if(b[i][j]==1)          PrintLCS(b, str1, i-1, j);      else          PrintLCS(b, str1, i, j-1);  }    int main(void)  {      char str1[100],str2[100];      int i,length1,length2,len;      printf("请输入第一个字符串：");      gets(str1);      printf("请输入第二个字符串：");      gets(str2);      length1 = strlen(str1);      length2 = strlen(str2);      //双指针的方法申请动态二维数组      int **b = new int*[length1+1];      for(i= 0; i < length1+1; i++)          b[i] = new int[length2+1];      len=LCSLength(str1,str2,b);      printf("最长公共子序列的长度为：%d\n",len);      printf("最长公共子序列为：");      PrintLCS(b,str1,length1,length2);      printf("\n");      for(i = 0; i < length1+1; i++)    //释放动态申请的二维数组          delete[] b[i];      delete[] b;      system("pause");      return 0;  }  

 

/**  找出两个字符串的最长公共子序列的长度 ** author :liuzhiwei   ** data   :2011-08-15 **/   #include "stdio.h"  #include "string.h"  #include "stdlib.h"  int LCSLength(char* str1, char* str2)    //求得两个字符串的最大公共子串长度并输出公共子串  {      int i,j,length1,length2;      length1 = strlen(str1);      length2 = strlen(str2);        //双指针的方法申请动态二维数组      int **c = new int*[length1+1];      //共有length1+1行      for(i = 0; i < length1+1; i++)          c[i] = new int[length2+1];      //共有length2+1列        for(i = 0; i < length1+1; i++)          c[i][0]=0;        //第0列都初始化为0      for(j = 0; j < length2+1; j++)          c[0][j]=0;        //第0行都初始化为0        for(i = 1; i < length1+1; i++)      {          for(j = 1; j < length2+1; j++)          {              if(str1[i-1]==str2[j-1])   //由于c[][]的0行0列没有使用，c[][]的第i行元素对应str1的第i-1个元素                  c[i][j]=c[i-1][j-1]+1;              else if(c[i-1][j]>c[i][j-1])                  c[i][j]=c[i-1][j];              else                  c[i][j]=c[i][j-1];          }      }        //输出公共子串      char s[100];      int len,k;      len=k=c[length1][length2];      s[k--]='\0';      i=length1,j=length2;      while(i>0 && j>0)      {          if(str1[i-1]==str2[j-1])          {              s[k--]=str1[i-1];              i--;              j--;          }          else if(c[i-1][j]<c[i][j-1])              j--;          else              i--;      }      printf("最长公共子串为：");      puts(s);        for(i = 0; i < length1+1; i++)    //释放动态申请的二维数组          delete[] c[i];      delete[] c;      return len;  }    int main(void)  {      char str1[100],str2[100];      int length1,length2,len;        printf("请输入第一个字符串：");      gets(str1);      printf("请输入第二个字符串：");      gets(str2);      length1 = strlen(str1);      length2 = strlen(str2);      len=LCSLength(str1,str2);      printf("最长公共子串的长度为：%d\n",len);      system("pause");      return 0;  }  

问题拓展：设A、B、C是三个长为n的字符串，它们取自同一常数大小的字母表。设计一个找出三个串的最长公共子序列的O(n^3)的时间算法。
       思路：跟上面的求2个字符串的公共子序列是一样的思路，只不过这里需要动态申请一个三维的数组，三个字符串的尾字符不同的时候，考虑的情况多一些而已。

/**  找出三个字符串的最长公共子序列的长度 ** author :liuzhiwei   ** data   :2011-08-15 **/   #include "stdio.h"  #include "string.h"  #include "stdlib.h"  int max1(int m,int n)  {      if(m>n)          return m;      else          return n;  }  int max2(int x,int y,int z,int k,int m,int n)  {      int max=-1;      if(x>max)          max=x;      if(y>max)          max=y;      if(z>max)          max=z;      if(k>max)          max=k;      if(m>max)          max=m;      if(n>max)          max=n;      return max;  }  int LCSLength(char* str1, char* str2, char* str3)    //求得三个字符串的最大公共子序列长度并输出公共子序列  {      int i,j,k,length1,length2,length3,len;      length1 = strlen(str1);      length2 = strlen(str2);      length3 = strlen(str3);        //申请动态三维数组      int ***c = new int**[length1+1];      //共有length1+1行      for(i = 0; i < length1+1; i++)      {          c[i] = new int*[length2+1];      //共有length2+1列          for(j = 0; j<length2+1; j++)              c[i][j] = new int[length3+1];      }        for(i = 0; i < length1+1; i++)      {          for(j = 0; j < length2+1; j++)              c[i][j][0]=0;      }      for(i = 0; i < length2+1; i++)      {          for(j = 0; j < length3+1; j++)              c[0][i][j]=0;      }      for(i = 0; i < length1+1; i++)      {          for(j = 0; j < length3+1; j++)              c[i][0][j]=0;         }        for(i = 1; i < length1+1; i++)      {          for(j = 1; j < length2+1; j++)          {              for(k = 1; k < length3+1; k++)              {                  if(str1[i-1]==str2[j-1] && str2[j-1]==str3[k-1])                      c[i][j][k]=c[i-1][j-1][k-1]+1;                  else if(str1[i-1]==str2[j-1] && str1[i-1]!=str3[k-1])                      c[i][j][k]=max1(c[i][j][k-1],c[i-1][j-1][k]);                  else if(str1[i-1]==str3[k-1] && str1[i-1]!=str2[j-1])                      c[i][j][k]=max1(c[i][j-1][k],c[i-1][j][k-1]);                  else if(str2[j-1]==str3[k-1] && str1[i-1]!=str2[j-1])                      c[i][j][k]=max1(c[i-1][j][k],c[i][j-1][k-1]);                  else                  {                      c[i][j][k]=max2(c[i-1][j][k],c[i][j-1][k],c[i][j][k-1],c[i-1][j-1][k],c[i-1][j][k-1],c[i][j-1][k-1]);                  }              }          }      }      len=c[length1][length2][length3];      for(i = 1; i < length1+1; i++)          //释放动态申请的三维数组      {          for(j = 1; j < length2+1; j++)              delete[] c[i][j];          delete[] c[i];      }      delete[] c;      return len;  }    int main(void)  {      char str1[100],str2[100],str3[100];      int len;        printf("请输入第一个字符串：");      gets(str1);      printf("请输入第二个字符串：");      gets(str2);      printf("请输入第三个字符串：");      gets(str3);      len=LCSLength(str1,str2,str3);      printf("最长公共子序列的长度为：%d\n",len);      system("pause");      return 0;  }