LCS（最长公共子序列）

    LCS         最长公共子序列

        LCS是Longest Common Subsequence的缩写，即最长公共子序列。一个序列，如果是两个或多个已知序列的子序列，且是所有子序列中最长的，则为最长公共子序列。   

解决方法

  对于一般的LCS问题，都属于NP问题。当数列的量为一定的时，都可以采用动态规划去解决。

算法

动态规划的一个计算最长公共子序列的方法如下，以两个序列 X、Y 为例子：

设有二维数组 f[i][j] 表示 X 的 i 位和 Y 的 j 位之前的最长公共子序列的长度，则有：

f[1][1] = same(1,1)

f[i][j] = max{f[i-1][j-1] + same(i,j),f[i-1][j],f[i][j-1]}

其中，same(a,b)当 X 的第 a 位与 Y 的第 b 位完全相同时为“1”，否则为“0”。

此时，f[i][j]中最大的数便是 X 和 Y 的最长公共子序列的长度，依据该数组回溯，便可找出最长公共子序列。

该算法的空间、时间复杂度均为O(n^2)，经过优化后，空间复杂度可为O(n)，时间复杂度为O(nlogn)。

代码

#include<cstdlib>
#include<cstring>
#include<iostream>
using namespace std;
#define N 105
int dp[N+1][N+1];
char str1[N],str2[N];
int maxx(int a,int b)
{
    if(a>b) return a;
    return b;
}
int LCSL(int len1,int len2)
{
    int i,j;
    int len=maxx(len1,len2);
    for(i=0;i<=len;i++)
    {
        dp[i][0]=0;dp[0][i]=0;
    }
    for(i=1;i<=len1;i++)
        for(j=1;j<=len2;j++)
        {
            if(str1[i-1]==str2[j-1])
            {
                dp[i][j]=dp[i-1][j-1]+1;
            }
            else
            {
                dp[i][j]=maxx(dp[i-1][j],dp[i][j-1]);
            }
        }
    return dp[len1][len2];
}
int main()
{
    while(cin>>str1>>str2)
    {
        int len1=strlen(str1);
        int len2=strlen(str2);
        cout<<LCSL(len1,len2)<<endl;
    }
    return 0;
}