最大公共子序列 LCS

http://dsqiu.iteye.com/blog/1701541

最长公共子序列

问题描述

最长公共子序列就是寻找两个给定序列的子序列，该子序列在两个序列中以相同的顺序出现，但是不必要是连续的。

动态规划求解

使用动态规划求解这个问题，先寻找最优子结构。设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，等等。

为了找到最长的LCS，我们定义dp[i][j]记录序列LCS的长度，合法状态的初始值为当序列X的长度为0或Y的长度为0，公共子序列LCS长度为0，即dp[i][j]=0，所以用i和j分别表示序列X的长度和序列Y的长度，状态转移方程为 dp[i][j] = 0 如果i=0或j=0 dp[i][j] = dp[i-1][j-1] + 1 如果X[i-1] = Y[i-1] dp[i][j] = max{ dp[i-1][j], dp[i][j-1] } 如果X[i-1] != Y[i-1] 求出了最长公共子序列的长度后，输出LCS就是输出dp的最优方案了，既可以用一个额外的矩阵存储路径，也可以直接根据状态转移矩阵倒推最优方案。

 复杂度分析：O（n^2)

#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);

}