Algorithm --> 最长公共子序列（LCS）

最新推荐文章于 2020-09-08 16:36:24 发布
最新推荐文章于 2020-09-08 16:36:24 发布
阅读量140 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/jeakeven/p/4570223.html
版权
 
一、什么是最长公共子序列
   
　　什么是最长公共子序列呢？举个简单的例子吧，一个数列S，若分别是两个或多个已知序列的子序列，且是所有符合条件序列中最长的，则S称为已知序列的最长公共子序列。
　　举例如下，如：有两个随机数列，1 2 3 4 5 6 和 3 4 5 8 9，则它们的最长公共子序列便是：3 4 5。
 
     最长公共子串（Longest Common Substirng）和最长公共子序列（Longest Common Subsequence，LCS）的区别为：子串是串的一个连续的部分，子序列则是从不改变序列的顺序，而从序列中去掉任意的元素而获得新的序列；也就是说，子串中字符的位置必须是连续的，子序列则可以不必连续。
 
 
 
二、解决方案

<1> 枚举法

       这种方法是最简单，也是最容易想到的，当然时间复杂度也是龟速的，我们可以分析一下，刚才也说过了cnblogs的子序列个数有27个 ，延伸一下：一个长度为N的字符串，其子序列有2N个，每个子序列要在第二个长度为N的字符串中去匹配，匹配一次需要O(N)的时间，总共也就是O(N*2N)，可以看出，时间复杂度为指数级，恐怖的令人窒息。

 

<2> 动态规划

最长公共子序列的结构有如下表示：

设序列X=<x1, x2, …, xm>和Y=<y1, y2, …, yn>的一个最长公共子序列Z=<z1, z2, …, zk>，则：
   1> 若 xm=yn，则 zk=xm=yn，且Zk-1是Xm-1和Yn-1的最长公共子序列； 
   2> 若 xm≠yn且 zk≠xm ，则 Z是 Xm-1和 Y的最长公共子序列；
   3> 若 xm≠yn且 zk≠yn ，则 Z是 X和 Yn-1的最长公共子序列；
 
现有两个序列X={x1,x2,x3，...xi}，Y={y1,y2,y3，....，yi}， 设一个C[i,j]: 保存Xi与Yj的LCS的长度，递推方程为：

代码：

    //只能打印一个最长公共子序列
    #include <iostream>
    using namespace std;
     
     const int X = 100, Y = 100;        //串的最大长度
     char result[X+1];                    //用于保存结果
     int count=0;                        //用于保存公共最长公共子串的个数

     /*功能：计算最优值
      *参数：
      *        x:字符串x
      *        y:字符串y
      *        b:标志数组
      *        xlen:字符串x的长度
      *        ylen:字符串y的长度
      *返回值：最长公共子序列的长度
      *
      */
     int Lcs_Length(string x, string y, int b[][Y+1],int xlen,int ylen)
     {
         int i = 0;
         int j = 0;

         int c[X+1][Y+1];
         for (i = 0; i<=xlen; i++)
         {
             c[i][0]=0;
         }
         for (i = 0; i <= ylen; i++ )
         {
             c[0][i]=0;
         }
         for (i = 1; i <= xlen; i++)
         {
             for (j = 1; j <= ylen; j++)
             {
                 if (x[i - 1] == y[j - 1])
                 {
                     c[i][j] = c[i-1][j-1]+1;
                     b[i][j] = 1;
                 }
                 else if (c[i-1][j] > c[i][j-1])
                 {
                     c[i][j] = c[i-1][j];
                     b[i][j] = 2;
                 }
                 else if(c[i-1][j] <= c[i][j-1])
                 {
                     c[i][j] = c[i][j-1];
                     b[i][j] = 3;
                 }
             }
         }
　　　　  return c[xlen][ylen];
     }
     
    void Display_Lcs(int i, int j, string x, int b[][Y+1],int current_Len)
     {
         if (i ==0 || j==0)
         {
             return;
         }
         if(b[i][j]== 1)
         {
             current_Len--;
             result[current_Len]=x[i- 1];
             Display_Lcs(i-1, j-1, x, b, current_Len);
         }
         else if(b[i][j] == 2)
         {
             Display_Lcs(i-1, j, x, b, current_Len);
         }
         else if(b[i][j]==3)
         {
              Display_Lcs(i, j-1, x, b, current_Len);
         }
         else
         {
              Display_Lcs(i-1,j,x,b, current_Len);
         }
     }
     
     int main(int argc, char* argv[])
     {
         string x = "ABCBDAB";
         string y = "BDCABA";
         int xlen = x.length();
         int ylen = y.length();

         int b[X + 1][Y + 1];

         int lcs_max_len = Lcs_Length( x, y, b, xlen,ylen );
         cout << lcs_max_len << endl;

         Display_Lcs( xlen, ylen, x, b, lcs_max_len );
         
         //打印结果如下所示
        for(int i = 0; i < lcs_max_len; i++)
        {
            cout << result[i];
        }
        cout << endl;
        return 0;
     }

 运行结果如下：

4
BDAB

 

由于有时并不是只有一个最长公共子序列，所以，对上面的代码进行改进，增加一个数组保存结果等....代码如下所示。

//求取所有的最长公共子序列
    #include <iostream>
    using namespace std;
     
     const int X = 100, Y = 100;        //串的最大长度
     char result[X+1];                    //用于保存结果
     int cnt = 0;                        //用于保存公共最长公共子串的个数

     /*功能：计算最优值
      *参数：
      *        x:字符串x
      *        y:字符串y
      *        b:标志数组
      *        xlen:字符串x的长度
      *        ylen:字符串y的长度
      *返回值：最长公共子序列的长度
      *
      */
     int Lcs_Length(string x, string y, int b[][Y+1],int xlen,int ylen)
     {
         int i = 0;
         int j = 0;

         int c[X+1][Y+1];
         for (i = 0; i<=xlen; i++)
         {
             c[i][0]=0;
         }
         for (i = 0; i <= ylen; i++ )
         {
             c[0][i]=0;
         }
         for (i = 1; i <= xlen; i++)
         {
            
             for (j = 1; j <= ylen; j++)
             {
                 if (x[i - 1] == y[j - 1])
                 {
                     c[i][j] = c[i-1][j-1]+1;
                     b[i][j] = 1;
                 }
                 else if (c[i-1][j] > c[i][j-1])
                 {
                     c[i][j] = c[i-1][j];
                     b[i][j] = 2;
                 }
                 else if(c[i-1][j] < c[i][j-1])
                 {
                     c[i][j] = c[i][j-1];
                     b[i][j] = 3;
                 }
                 else
                 {
                     c[i][j] = c[i][j-1]; //或者c[i][j]=c[i-1][j];
                     b[i][j] = 4;
                 }
             }
         }
   　　　　return c[xlen][ylen];
     }
     
     /*功能：计算最长公共子序列
      *参数：
      *        xlen:字符串x的长度
      *        ylen:字符串y的长度
      *        x    :字符串x
      *        b:标志数组
      *        current_len:当前长度
      *        lcs_max_len:最长公共子序列长度
      *
      */
     void Display_Lcs(int i, int j, string x, int b[][Y+1],int current_len,int lcs_max_len)
     {
         if (i ==0 || j==0)
         {
             for(int s=0; s < lcs_max_len; s++)
             {
                 cout << result[s];
             }
             cout<<endl;
             cnt++;
             return;
         }
         if(b[i][j]== 1)
         {
             current_len--;
             result[current_len]=x[i- 1];
             Display_Lcs(i-1, j-1, x, b,current_len,lcs_max_len);
         }
         else if(b[i][j] == 2)
         {
             Display_Lcs(i-1, j, x, b,current_len,lcs_max_len);
         }
         else if(b[i][j]==3)
         {
             Display_Lcs(i, j-1, x, b,current_len,lcs_max_len);
         }
         else
         {
             Display_Lcs(i,j-1,x,b,current_len,lcs_max_len);
             Display_Lcs(i-1,j,x,b,current_len,lcs_max_len);
         }
     }
     
     int main(int argc, char* argv[])
     {
         string x = "ABCBDAB";
         string y = "BDCABA";
         int xlen = x.length();
         int ylen = y.length();

         int b[X + 1][Y + 1];

         int lcs_max_len = Lcs_Length( x, y, b, xlen,ylen );
         cout << lcs_max_len << endl;

         Display_Lcs( xlen, ylen, x, b, lcs_max_len, lcs_max_len );
         cout << "共有：" << cnt << "种";

         return 0;
     }

 

运行结果如下：

4
BDAB
BCAB
BCBA
共有： 3 种

 

 

 

 /****************************************

 　　　　update

 ****************************************/

示例： 

#include <iostream>
using namespace std;
#define X_LEN  7
#define Y_LEN  6
#define EQUAL  0
#define UP    1
#define LEVEL  2
void lcs_length(char* X,char* Y,int c[X_LEN+1][Y_LEN+1],int b[X_LEN+1][Y_LEN+1]);
void print_lcs(int b[X_LEN+1][Y_LEN+1],char *X,int i,int j);

int main()
{
    char X[X_LEN+1] = {' ','A','B','C','B','D','A','B'};
    char Y[Y_LEN+1] = {' ','B','D','C','A','B','A'};
    int c[X_LEN+1][Y_LEN+1]={0};
    int b[X_LEN+1][Y_LEN+1] = {0};
    int i,j;
    lcs_length(X,Y,c,b);
    for(i=0;i<=X_LEN;i++)
    {
         for(j=0;j<=Y_LEN;j++)
            cout<<c[i][j]<<" ";
        cout<<endl;
    }
    cout<<"The length of LCS is: "<<c[X_LEN][Y_LEN]<<endl;
    cout<<"The longest common subsequence between X and y is: "<<endl;
    print_lcs(b,X,X_LEN,Y_LEN);
    return 0;
}
//采用动态规划方法自底向上的进行计算，寻找最优解
void lcs_length(char* X,char* Y,int c[X_LEN+1][Y_LEN+1],int b[X_LEN+1][Y_LEN+1])
{
    int i,j;
    //设置边界条件，即i=0或者j=0
    for(i=0;i<X_LEN;i++)
        c[i][0] = 0;
    for(j=0;j<Y_LEN;j++)
        c[0][j] = 0;
    for(i=1;i<=X_LEN;i++)
        for(j=1;j<=Y_LEN;j++)
        {
            if(X[i] == Y[j])   //满足递归公式第二条
            {
                c[i][j] = c[i-1][j-1]+1;
                b[i][j] = EQUAL ;
            }
            else if(c[i-1][j] >= c[i][j-1])  //递归公式第三条
            {
                c[i][j] = c[i-1][j];
                b[i][j] = UP;
            }
            else
            {
                c[i][j] = c[i][j-1];
                b[i][j] = LEVEL;
            }
        }
}
void print_lcs(int b[X_LEN+1][Y_LEN+1],char *X,int i,int j)
{
    if(i==0 || j==0)
        return;
    if(b[i][j] == EQUAL)
    {
        print_lcs(b,X,i-1,j-1);
        cout<<X[i]<<" ";
    }
    else
        if(b[i][j] == UP)
            print_lcs(b,X,i-1,j);
    else
        print_lcs(b,X,i,j-1);
}

结果：

 

 

 

转载于:https://www.cnblogs.com/jeakeven/p/4570223.html

weixin_30951743
关注
Algorithm LCS最长公共子序列
A land whole of flowers.
02-14 231
算法： 递归法：对于序列A[0,n]]和B[0,m],LCS(A,B)无非三种情况 若A或B为空，则取作空序列，作为递归基 如果末字符相等，即A[n]=B[m]=‘X’，则取LCS(A[0,n),B[0,m))+‘X’，如果前者可以求解，则问题的规模被缩小 如果末字符不相等，即A[n]!=B[m]，比如A[n]=a,B[m]=b,则a和b至多有一个会出现在最后的解里（对解有贡献）。因为...
NYOJ - 36 - 最长公共子序列(LCS,动态规划DP)
i逆天耗子
10-19 485
描述 咱们就不拐弯抹角了，如题，需要你做的就是写一个程序，得出最长公共子序列。 tip：最长公共子序列也称作最长公共子串(不要求连续)，英文缩写为LCS（Longest Common Subsequence）。其定义是，一个序列 S ，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共子序列。 输入第一行给出一个整数N(0
Algorithm3——最长公共子序列(LCS)
leeayu的博客
09-21 432
本系列算法实现都是在学习数据结构（C++语言版），清华大学邓俊辉教授编，听邓老师edX网课过程中自己实现的例子。参考链接 神奕的博客——【动态规划】输出所有的最长公共子序列 米铺架构师——经典算法题每日演练——第四题 最长公共子序列 Q: (1)找到LCS的长度 (2)找到其中一个LCS序列 (3)找出所有LCS序列A: 以下代码实现解决以上三个问题，第一个链接主要解决第三个问题，第二个链接解决
Algorithm:最长公共子序列(LCS) 动规
weixin_41297324的博客
03-21 185
递归比递推慢！ /* 输入： abcdbc abfcab programming contest abcd mnp 输出： 4 2 0 */ /* 最长公共子序列： MaxLen(n,0)=0 n=0.....len1 MaxLen(0,n)=0 n=0.....len2 递推公式： if(s1[i-1]==s2[j-1]) MaxLen(i,j)=MaxLen(i-1...
最长公共子序列（LCS）问题－－动态规划
漫漫程序路
10-29 258
一、问题描述 一、什么是最长公共子序列    什么是最长公共子序列呢？举个简单的例子吧，一个数列S，若分别是两个或多个已知序列的子序列，且是所有符合条件序列中最长的，则S称为已知序列的最长公共子序列。   举例如下，如：有两个随机数列，1 2 3 4 5 6 和 3 4 5 8 9，则它们的最长公共子序列便是：3 4 5。   最长公共子串（Longest Common
求解两个字符串的最长公共子序列
weixin_33907511的博客
06-09 1245
一，问题描述 给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。比如字符串1：BDCABA；字符串2：ABCBDAB 则这两个字符串的最长公共子序列长度为4，最长公共子序列是：BCBA   二，算法求解 这是一个动态规划的题目。对于可用动态规划求解的问题，一般有两个特征：①最优子结构；②重叠子问题 ①最优子结构 设 X=(x1,x2,...
LCS.rar_LCS_lcs algorithm_最长公共子序列
09-23
最长公共子序列（Longest Common Subsequence，简称LCS）是计算机科学中一种经典的问题，主要涉及字符串或序列的比较。在本压缩包文件"LCS.rar"中，包含了一个名为"LCS"的程序，该程序可能用C++实现了KMP算法来解决...
动态规划--最长递增子序列(LIS)-最长公共子序列(LCS)
一只IT小小鸟
03-24 481
动态规划--最长递增子序列(LIS)-最长公共子序列(LCS)LIS最长递增子序列，朴素的是o(n^2)算法，二分下可以写成o(nlgn)：维护一个当前最优的递增序列——找到恰好大于它更新LCS最长公共子序列，通常o(n^2)的算法************************************************************************************...
C++实现求最长公共子序列（LCS）与最长公共子串(DP)
qq_23304241的博客
04-17 2104
#include <iostream> #include<algorithm> #include<vector> #include <string> using namespace std; int lcs(string str1, string str2) //最长公共子序列 { int len1 = str1.size(); int...
Ruby实现的最长公共子序列算法
01-21
最长公共子序列，LCS，动态规划实现。 #encoding: utf-8 #author: xu jin, 4100213 #date: Nov 01, 2012 #Longest-Commom-Subsequence #to find a longest commom subsequence of two given character arrays by ...
最长公共子序列及其变形（Human Gene Functions）（新加了一些内容）
大众博客
08-22 952
今天我想讲一下最长公共子序列的问题，希望会对读者有很大的帮助。(我希望读者可以坚持看完) 首先我们来一个最简单（相对于最长公共子序列的题来说）的题目： 最长公共子序列问题 Time Limit: 1000MS Memory limit: 65536K 题目描述  给定两个序列X= 输入 输入数据有多组，每组有两行 ，每行为一个长
LCS问题一：输出两个字符串的最长公共子串（Longest Common Substring）
qq_28619473的博客
03-17 5097
回到最常见的字符串问题了，这里的找两个字符串的最长公共子串，要求在原字符串中是连续的。其实和上面两个问题一样，这里依旧可以用动态规划来求解，其实博主自己也不大擅长动态规划，但是可以仿照上面的思路来操作。我们采用一个二维矩阵来记录中间的结果。这个二维矩阵怎么构造呢？直接举个例子吧："bab"和"caba"，则数组如下： 　　b a b c 0 0 0 ...
最长公共子序列以及最长公共子串
weixin_43743711的博客
09-08 316
前言： # include <iostream> # include <string> # include <algorithm> # include <cstring> # include <vector> using namespace std; const int N = 1100; int dp[N][N]; int main(void) { string s,t; cin>>s>>t; f
求两个字符串的最长公共子序列
南方以北
08-12 7938
  具体的算法思想参考以下文章： http://blog.csdn.net/lisonglisonglisong/article/details/41548557 http://blog.csdn.net/zhongkeli/article/details/8847694 https://www.kancloud.cn/digest/pieces-algorithm/163624  ...
最长公共子序列与最长公共子串(DP)
热门推荐
铭霏的记事本
11-16 2万+
1. 问题描述 子串应该比较好理解，至于什么是子序列，这里给出一个例子：有两个母串 cnblogsbelong 比如序列bo, bg, lg在母串cnblogs与belong中都出现过并且出现顺序与母串保持一致，我们将其称为公共子序列。最长公共子序列（Longest Common Subsequence, LCS），顾名思义，是指在所有的子序列中最长的那一个。子串是要求更严格的一种
最长公共子序列（信息学奥赛一本通-T1265）
Alex_McAvoy的博客
05-31 4060
【题目描述】 一个给定序列的子序列是在该序列中删去若干元素后得到的序列。确切地说，若给定序列X=&lt;x1,x2,…,xm&gt;，则另一序列Z＝&lt;z1，z2，…，zk&gt;是X的子序列是指存在一个严格递增的下标序列&lt;i1,i2,…,ik&gt;,使得对于所有j=1,2,…,k有：Xij=Zj 例如，序列Z=&lt;B,C,D,B&gt;是序列X=&lt;A,B,C...
[求最长公共子串（Longest Common Subsequence, LCS）][解题方法]
jbm
06-09 309
  问题 如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中，则字符串一称之为字符串二的子串。        注意，并不要求子串（字符串一）的字符必须连续出现在字符串二中。       请编写一个函数，输入两个字符串，求它们的最长公共子串，并打印出最长公共子串。       例如：输入两个字符串BDCABA和ABCBDAB，字符串BCBA和BDAB都是是它们的最长公共子...
NLP文本相似度 - LCS（最长公共子序列）java代码
jast
07-17 1200
LCS是Longest Common Subsequence的缩写，即最长公共子序列。一个序列，如果是两个或多个已知序列的子序列，且是所有子序列中最长的，则为最长公共子序列。 比如，对于char x[]="aabcd";有顺序且相互相邻的aabc是其子序列，有顺序但是不相邻的abc也是其公共子序列。即，只要得出序列中各个元素属于所给出的数列，就是子序列。 再加上char y[]="12a...
掌握KMP算法在C++中实现最长公共子序列
资源摘要信息: "LCS算法是用于在两个序列中找出最长公共子序列的问题解决方案，属于计算理论中动态规划的典型应用之一。最长公共子序列问题（LCS，Longest Common Subsequence Problem）是寻找两个或多个已知序列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值