經典的問題，在各大部落格上有數不清的好帖子

下面為最常見的n^2演算法

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
using namespace std;
int f[500][500];
char x[500],y[500];
int solve(int a,int b)
{
  int i,j;
  memset(f,0,sizeof(f));
  for(i=1;i<=a;i++)
  {
     for(j=1;j<=b;j++)
     {
        if(x[i]==y[j])
        {
            f[i][j]=f[i-1][j-1]+1;
        }
        else
        f[i][j]=max(f[i-1][j],f[i][j-1]);
     }
  }
  return f[a][b];
}
int main()
{
    int a,b;
    while(scanf("%s",&x[1])!=EOF)
    {
        scanf("%s",&y[1]);
        a=strlen(&x[1]);
        b=strlen(&y[1]);
        printf("%d\n",solve(a,b));

    }
    return 0;
}
 

O(nlogn)：

最長公共子序列（LCS）最常見的演算法是時間複雜度為O(n^2)的動態規劃(DP)演算法，但在James W. Hunt和Thomas G. Szymansky 的論文"A Fast Algorithm for Computing Longest Common Subsequence"中，給出了O(nlogn)下限的一種演算法。

定理：設序列A長度為n，{A(i)}，序列B長度為m，{B(i)}，考慮A中所有元素在B中的序號，即A某元素在B的序號為{P_k1,P_k2,..}，將這些序號按照降序排列，然後按照A中的順序得到一個新序列，此新序列的最長嚴格遞增子序列即對應為A、B的最長公共子序列。

舉例來說，A={a,b,c,d,b}，B={b,c,a,b}，則a對應在B的序號為2，b對應序號為{4,0}，c對應序號為1，d對應為空集，生成的新序列為{2,4, 0, 1, 4, 0}，其最長嚴格遞增子序列為{0,1,4}，對應的公共子序列為{b, c, b}

原論文的證明過程較複雜，其實可以簡單的通過一一對應來證明。即證明A、B的一個公共子序列和新序列的一個嚴格遞增子序列一一對應。

(1) A、B的一個公共子序列對應新序列的一個嚴格遞增子序列

假設A、B的某一個公共子序列長度為k，則其公共子序列在A和B中可以寫為

{A_i1,A_i2, ..., A_ik}

{B_j1,B_j2, ..., B_jk

如此有A_i1 = A_j1,A_i2 = A_j2, ...., A_ik = A_jk, 考慮元素B_j1在B中的序號P(B_j1)，則有

P(B_j1)< P(B_j2) < ... < P(B_jk)

注意此嚴格遞增子序列屬於新序列的一個子序列，因此得證

(2) 新序列的一個嚴格遞增子序列對應A、B的一個公共子序列

設新序列的一個嚴格遞增子序列{P₁,P₂, ..., P_k}，任意兩個相信的P不可能屬於A中同一個元素，因為A中某元素在B中的序號按照降序排列，但此序列為嚴格遞增序列，矛盾。所以每個P均對應於A中不同位置的元素，設為{A_i1, A_i2, ..., A_ik}。

因為P是嚴格遞增序列，則每個P也對應B中唯一的一個元素，假設為{B_j1,B_j2, ..., B_jk}，由P的定義可知A_i1= A_j1, A_i2 = A_j2, ...., A_ik = A_jk，因此得證。

實現上比較複雜，有以下幾個步驟：

(1) 對序列B排序

(2) 計算A中每個元素在B中的序號，並構成新序列

(3) 使用LIS的方法計算最長嚴格遞增子序列

(4) 獲取最長公共子序列

效能分析：

(1) 排序複雜度為nlogn

(2) 獲取一個元素在B中的序號的複雜度，最小為logn，最大為n，獲取所有元素的複雜度為 nlogn === n*n

(3) LIS 複雜度為nlogn

因此總體複雜度在nlogn 到 n*n logn之間，但如果(2) 步驟中A中元素在B中的序號對數很少時，效能相當優越，在實際測試時，string 中均為小寫字母，長度為10000的情況下，這種方法比普通的LCS快一倍以上；如果string 中的字元擴充套件成char，即0-255，則這種方法比普通的LCS快至少一個數量級。以下為程式碼實現，可以參考：

附個參考程式碼：

1. #include <stdio.h>  
2. #include <ctype.h>  
3. #include <string.h>  
4. #include <iostream>  
5. #include <string>  
6. #include <math.h>  
7. #include <vector>  
8. #include <queue>  
9. #include <algorithm>  
10. using namespace std;  
11. const int maxn = 1501 ;  
12. vector<int> location[26] ;  
13. int c[maxn*maxn] , d[maxn*maxn] ;  
14. inline int get_max(int a,int b) {   return a > b ? a : b ;  }  
15. //nlogn 求lcs  
16. int lcs(char a[],char b[])  
17. {  
18.     int i , j , k , w , ans , l , r , mid ;  
19.     for( i = 0 ; i < 26 ; i++) location[i].clear() ;  
20.     for( i = strlen(b)-1 ; i >= 0 ; i--) location[b[i]-'a'].push_back(i) ;  
21.     for( i = k = 0 ; a[i] ; i++)  
22.     {  
23.         for( j = 0 ; j < location[w=a[i]-'a'].size() ; j++,k++) c[k] = location[w][j] ;  
24.     }  
25.     d[1] = c[0] ;   d[0] = -1 ;  
26.     for( i = ans = 1 ; i < k ; i++)  
27.     {  
28.         l = 0 ; r = ans ;  
29.         while( l <= r )  
30.         {  
31.             mid = ( l + r ) >> 1 ;  
32.             if( d[mid] >= c[i] ) r = mid - 1 ;  
33.             else l = mid + 1 ;  
34.         }  
35.         if( r == ans ) ans++,d[r+1] = c[i] ;  
36.         else if( d[r+1] > c[i] ) d[r+1] = c[i] ;  
37.     }  
38.     return ans ;  
39. }  
40. int main()  
41. {  
42.     char a[maxn] , b[maxn] ;  
43.     while (~scanf("%s%s",a,b))  
44.     {  
45.         printf("%d/n",lcs(a,b));  
46.     }  
47. } 

本文出自 “[email protected]” 部落格，請務必保留此出處http://karsbin.blog.51cto.com/1156716/966387

相關題目：

POJ1458
POJ2250
POJ1159
基本的最長公共子序列

POJ2533
最長不減(不增)子序列,用方法1、2即可

WOJ1398
最長不減(不增)子序列,方法1、2超時