[Data Structure] LCSs——最長公共子序列和最長公共子串

1. 什么是 LCSs？

　　什么是 LCSs? 好多博友看到這幾個字母可能比較困惑，因為這是我自己對兩個常見問題的統稱，它們分別為最長公共子序列問題（Longest-Common-Subsequence）和最長公共子串（Longest-Common-Substring）問題。這兩個問題非常的相似，所以對不熟悉的同學來說，有時候很容易被混淆。下面讓我們去好好地理解一下兩者的區別吧。

1.1 子序列 vs 子串

　　子序列是有序的，但不一定是連續，作用對象是序列。

　　例如：序列 X = <B, C, D, B> 是序列 Y = <A, B, C, B, D, A, B> 的子序列，對應的下標序列為 <2, 3, 5, 7>。

　　子串是有序且連續的，左右對象是字符串。

　　例如 a = abcd 是 c = aaabcdddd 的一個子串；但是 b = acdddd 就不是 c 的子串。

1.2 最長公共子序列 vs 最長公共子串

　　最長公共子序列和最長公共子串是常見的兩種問題，雖然兩者問題很相似，也均可以根據動態規划進行求解，但是兩者的本質是不同的。

　　最長公共子序列問題是針對給出的兩個序列，求兩個序列最長的公共子序列。

　　最長公共子串問題是針對給出的兩個字符串，求兩個字符串最長的公共子串（有關字符串匹配相關算法可以轉至博客《[Algorithm] 字符串匹配算法——KMP算法》）。

2. 動態規划方法求解LCSs

　　前面提到，動態規划方法均可以用到最長公共子序列和最長公共子串問題當中，在這里我們就不一一進行求解了。我們以最長公共子序列為例，介紹一下如何利用動態規划的思想來解決 LCSs。

　　給定兩個序列，找出在兩個序列中同時出現的最長子序列的長度。對於每一個序列而言，其均具有 $a^{m}$ 中子序列，因此采用暴力算法的時間復雜度是指數級的，這顯然不是一種好的解決方案。

　　下面我們看一下，如何使用動態規划的思想來解決最大公共子序列問題。

　　首先考慮最大公共子序列問題是否滿足動態規划問題的兩個基本特性：

　　1. 最優子結構：

　　設輸入序列是X [0 .. m-1] 和 Y [0 .. n-1]，長度分別為 m 和 n。和設序列 L(X [0 .. m-1]，Y[0 .. n-1]) 是這兩個序列的 LCS 的長度，以下為 L(X [0 .. M-1]，Y [0 .. N-1]) 的遞歸定義：

　　1）如果兩個序列的最后一個元素匹配（即X [M-1] == Y [N-1]）

　　則：L（X [0 .. M-1]，Y [0 .. N-1]）= 1 + L（X [0 .. M-2]，Y [0 .. N-1]）

　　2）如果兩個序列的最后字符不匹配（即X [M-1] != Y [N-1]）
　　則：L(X [0 .. M-1]，Y [0 .. N-1]) = MAX(L(X [0 .. M-2]，Y [0 .. N-1])，L(X [0 .. M-1]，Y [0 .. N-2]))

　　通過如下具體實例來更好地理解一下：

　　1）考慮輸入子序列 <AGGTAB> 和 <GXTXAYB>。最后一個字符匹配的字符串。這樣的 LCS 的長度可以寫成：

L(<AGGTAB>, <GXTXAYB>) = 1 + L(<AGGTA>, <GXTXAY>)

　　2）考慮輸入字符串“ABCDGH”和“AEDFHR。最后字符不為字符串相匹配。這樣的LCS的長度可以寫成：

L(<ABCDGH>, <AEDFHR>) = MAX ( L(<ABCDG>, <AEDFHR>), L(<ABCDGH>, <AEDFH>) )

　　因此，LCS問題有最優子結構性質。

　　2. 重疊子問題：

　　很明顯，基於上述的分析，LCS 很多子問題也都共享子子問題，因此可以對其進行遞歸求解。具體的算法時間度為 O(m*n)，可以優化至 O(m+n)。

　　下圖給出了回溯法找出LCS的過程：

　　具體的C++實現代碼如下：

/ *動態規划實現的LCS問題* /
#include<stdio.h>
#include<stdlib.h>

int max(int a, int b);

/* Returns length of LCS for X[0..m-1], Y[0..n-1] */
int lcs( char *X, char *Y, int m, int n )
{
   int L[m+1][n+1];
   int i, j;

   /* Following steps build L[m+1][n+1] in bottom up fashion. Note 
      that L[i][j] contains length of LCS of X[0..i-1] and Y[0..j-1] */
   for (i=0; i<=m; i++)
   {
     for (j=0; j<=n; j++)
     {
       if (i == 0 || j == 0)
         L[i][j] = 0;

       else if (X[i-1] == Y[j-1])
         L[i][j] = L[i-1][j-1] + 1;

       else
         L[i][j] = max(L[i-1][j], L[i][j-1]);
     }
   }

   /* L[m][n] contains length of LCS for X[0..n-1] and Y[0..m-1] */
   return L[m][n];
}

/* Utility function to get max of 2 integers */
int max(int a, int b)
{
    return (a > b)? a : b;
}

/*測試上面的函數 */
int main()
{
  char X[] = "AGGTAB";
  char Y[] = "GXTXAYB";

  int m = strlen(X);
  int n = strlen(Y);

  printf("Length of LCS is %d\n", lcs( X, Y, m, n ) );

  getchar();
  return 0;
}

　　Python實現代碼如下：

def lcs(a,b):
  lena=len(a)
  lenb=len(b)
  c=[[0 for i in range(lenb+1)] for j in range(lena+1)]
  flag=[[0 for i in range(lenb+1)] for j in range(lena+1)]
  for i in range(lena):
    for j in range(lenb):
      if a[i]==b[j]:
        c[i+1][j+1]=c[i][j]+1
        flag[i+1][j+1]='ok'
      elif c[i+1][j]>c[i][j+1]:
        c[i+1][j+1]=c[i+1][j]
        flag[i+1][j+1]='left'
      else:
        c[i+1][j+1]=c[i][j+1]
        flag[i+1][j+1]='up'
  return c,flag

def printLcs(flag,a,i,j):
  if i==0 or j==0:
    return
  if flag[i][j]=='ok':
    printLcs(flag,a,i-1,j-1)
    print(a[i-1],end='')
  elif flag[i][j]=='left':
    printLcs(flag,a,i,j-1)
  else:
    printLcs(flag,a,i-1,j)
    
a='ABCBDAB'
b='BDCABA'
c,flag=lcs(a,b)
for i in c:
  print(i)
print('')
for j in flag:
  print(j)
print('')
printLcs(flag,a,len(a),len(b))
print('')

　　awk 命令也可以很容易的寫出 LCS 的代碼：

echo "123456abcd567
234dddabc45678"|awk -vFS="" 'NR==1{str=$0}NR==2{N=NF;for(n=0;n++<N;){s="";for(t=n;t<=N;t++){s=s""$t;if(index(str,s)){a[n]=t-n;b[n]=s;if(m<=a[n])m=a[n]}else{t=N}}}}END{for(n=0;n++<N;)if(a[n]==m)print b[n]}'

3. 參考內容

　　1. 《算法導論》動態規划之最長公共子序列；