最长公共子序列(LCS)

原创 2016年08月31日 17:06:23

递归实现

int lcs(char *T, char *P, int n, int m)
{
    if (n < 1 || m < 1)
        return 0;
    else if (T[n] == T[m])
        return lcs(T, P, n - 1, m - 1) + 1;
    else
    {
        int left = lcs(T, P, n - 1, m);
        int right = lcs(T, P, n, m - 1);
        return left>right ? left : right;
    }       

}

动态规划(迭代版)

通过牺牲内存换取速度

// 返回长度值
int lcs2(char *T, char *P, int n, int m){
    n++, m++;
    int *array=new int[n*m]
    for(int i=0;i<n;i++){
        array[i*m]= 0;
    }
    for(int i=1;i<m;i++){
        array[i]= 0;
    }
    for(int i=1; i<n-1;i++){
        for(int j=1; j< m-1; j++){
            if(T[i] == P[j]){
                array[i*m+j] = array[(i-1)*m+j-1] + 1;
            }
            else{
                int left = array[i*m+j-1];
                int top = array[(i-1)*m+j];
                array[i*m+j]=left > top? left:top;
            }
        }
    }
    int result = array[m*n-1];
    char *output = new char[result];
    //回溯输出子序列
    backtrack(T, array, n, m, output, result);
    //此处输出LCS的一种可能的结果
    printf("%s", output);
    delete[] output ;
    delete[] array;
    return result ;
}

回溯输出最长的公共子序列

void backtrack(char *T, int *array, int n, int m, char *output, int lcs_len){
    for (int i = n - 1, j = m - 1; i>0 && j>0;){
        if (array[i*m + j] == array[i*m + j -1]){
            j--;
        }
        else if (array[i*m + j] == array[(i - 1)*m + j])
            i--;
        else{
            output[--lcs_len] = T[i - 1];
            i--, j--;
        }

    }
}

动态规划(节省内存版本)

如果只需要输出LCS的长度,不需要输出LCS可能的值,可以用空间压缩的方法将额外的空间减少为O{min(M,N)}

int lcs3(char * T, char *P, int n, int m)
{
    n++;
    int *listT = new int[n];//初始化一个列表
    int *listP = new int[m*2];
    for (int i = 0; i < n; i++)
    {
        listT[i] = 0;
    }
    for (int j = 0; j < m; j++)
    {
        listP[j] = 0;
    }
    int flag1 = 1;
    int flag2 = 0;
    for (int i = 0; i < n-1; i++){
        for (int j = 0; j < m; j++){
            if (T[i] == P[j]){
                listP[flag1*m + j] = (j == 0 ? listT[i] + 1 : listP[flag2*m + j - 1] + 1);
            }   
            else{
                int left = j == 0 ? listT[i+1] : listP[flag1*m + j - 1];
                listP[flag1*m + j] = left > listP[flag2*m + j] ? left : listP[flag2*m + j];
            }

        }
        flag1 = flag2;
        flag2 = -flag2 + 1;
    }
    int rerult = listP[flag2*m + m - 1];
    delete[] listT;
    delete[] listP;
    return rerult;

}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

最长公共子序列 LCS

最长公共子序列LCS

  • 2008-07-25 16:08
  • 30KB
  • 下载

《github一天一道算法题》:动态规划法解决最长公共子序列(LCS)问题的最简单方法

/* * copyleft@hustyangju * 问题:longest common subsequece problem * 思路:从底往上,利用动态规划,划分子问题,利用LCS子问题的长...

【字符串系列】最长公共子序列(LCS)

LCS(longest common subsequent),暴力求解的复杂度为O(2^m*2^n),用dp求解的时间复杂度为O(m+n),本博文主要介绍LCS的dp求法,并且给出一点对应的模板题。 ...

LCS最长公共子序列算法

  • 2012-09-19 21:59
  • 456KB
  • 下载

poj1159Palindrome(LCS最长公共子序列变形)

Palindrome Time Limit: 3000MS   Memory Limit: 65536K Total Submissions: 60920   Ac...

LCS 最长公共子序列 JAVA

  • 2010-06-27 10:10
  • 614B
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)