LCS 算法：Javascript 最长公共子序列

最新推荐文章于 2022-05-24 17:23:15 发布
最新推荐文章于 2022-05-24 17:23:15 发布
阅读量788 收藏
点赞数

（点击上方公众号，可快速关注）

英文：Kaelan Cooter  译文：开源中国

https://www.oschina.net/translate/what-im-looking-for-from-frontend-in-2018


最长公共子序列（Longest Common Subsequence LCS）是从给定的两个序列X和Y中取出尽可能多的一部分字符，按照它们在原序列排列的先后次序排列得到。LCS问题的算法用途广泛，如在软件不同版本的管理中，用LCS算法找到新旧版本的异同处;在软件测试中，用LCS算法对录制和回放的序列进行比较，在基因工程领域，用LCS算法检查患者DNA连与键康DNA链的异同;在防抄袭系统中，用LCS算法检查论文的抄袭率。LCS算法也可以用于程序代码相似度度量，人体运行的序列检索，视频段匹配等方面，所以对LCS算法进行研究具有很高的应用价值。

基本概念

1、子序列(subsequence)： 一个特定序列的子序列就是将给定序列中零个或多个元素去掉后得到的结果(不改变元素间相对次序)。例如序列的子序列有：、、等。

2、公共子序列(common subsequence)： 给定序列X和Y，序列Z是X的子序列，也是Y的子序列，则Z是X和Y的公共子序列。例如X=[A,B,C,B,D,A,B]，Y=[B,D,C,A,B,A[，那么序列Z=[B,C,A]为X和Y的公共子序列，其长度为3。但Z不是X和Y的最长公共子序列，而序列[B,C,B,A]和[B,D,A,B]也均为X和Y的最长公共子序列，长度为4，而X和Y不存在长度大于等于5的公共子序列。对于序列[A,B,C]和序列[E,F,G]的公共子序列只有空序列[]。

3、最长公共子序列：给定序列X和Y，从它们的所有公共子序列中选出长度最长的那一个或几个。

4、子串： 将一个序列从最前或最后或同时删掉零个或几个字符构成的新系列。区别与子序列，子序列是可以从中间抠掉字符的。cnblogs这个字符串中子序列有多少个呢？很显然有27个，比如其中的cb,cgs等等都是其子序列

给一个图再解释一下：

我们可以看出子序列不见得一定是连续的，连续的是子串。

问题分析

我们还是从一个矩阵开始分析,自己推导出状态迁移方程。

首先，我们把问题转换成前端够为熟悉的概念，不要序列序列地叫了，可以认为是数组或字符串。一切从简，我们就估且认定是两个字符串做比较吧。

我们重点留意”子序列“的概念，它可以删掉多个或零个，也可以全部干掉。这时我们的第一个子序列为空字符串（如果我们的序列不是字符串，我们还可以 ）！这个真是千万要注意到！许多人就是看不懂《算法导论》的那个图表，还有许多博客的作者不懂装懂。我们总是从左到右比较，当然了第一个字符串，由于作为矩阵的高，就垂直放置了。

x""BDCABA
""






A






B






C






D






A






B






假令X ＝ "ABCDAB"， Y＝"BDCABA"，各自取出最短的序列，也就是空字符串与空字符串比较。LCS的方程解为一个数字，那么这个表格也只能填数字。两个空字符串的公同区域的长度为0.

x""BDCABA
""0





A






B






C






D






A






B






然后我们X不动，继续让空字符串出阵，Y让“B”出阵，很显然，它们的公共区域的长度为0. Y换成其他字符， D啊，C啊， 或者， 它们的连续组合DC、 DDC， 情况没有变， 依然为0. 因此第一行都为0. 然后我们Y不动，Y只出空字任串，那么与上面的分析一样，都为0，第一列都是0.

x""BDCABA
""0000000
A0





B0





C0





D0





A0





B0





LCS问题与背包问题有点不一样，背包问题还可以设置-1行，而最长公共子序列因为有空子序列的出现，一开始就把左边与上边固定死了。

然后我们再将问题放大些，这次双方都出一个字符，显然只有两都相同时，才有存在不为空字符串的公共子序列，长度也理解数然为1。

A为"X", Y为"BDCA"的子序列的任意一个

x""BDCABA
""0000000
A00001

B0





C0





D0





A0





B0





继续往右填空，该怎么填？显然，LCS不能大于X的长度，Y的从A字符串开始的子序列与B的A序列相比，怎么也能等于1。

x""BDCABA
""0000000
A0000111
B0





C0





D0





A0





B0





如果X只从派出前面个字符A,B吧，亦即是“”，“A”, "B", "AB"这四种组合，前两个已经解说过了。那我们先看B，${X1} == ${Y0}， 我们得到一个新的公共子串了，应该加1。为什么呢？因为我们这个矩阵是一个状态表，从左到右，从上到下描述状态的迁移过程，并且这些状态是基于已有状态累加出来的。现在我们需要确认的是，现在我们要填的这个格子的值与它周围已经填好的格子的值是存在何种关系。目前，信息太少，就是一个孤点，直接填1。

x""BDCABA
""0000000
A0000111
B01




C0





D0





A0





B0





然后我们让Y多出一个D做帮手，{"",A,B,AB} vs {"",B,D,BD}，显然，继续填1. 一直填到Y的第二个B之前，都是1。 因为到BDCAB时，它们有另一个公共子序列，AB。

x""BDCABA
""0000000
A0000111
B011112
C0





D0





A0





B0





到这一步，我们可以总结一些规则了，之后就是通过计算验证我们的想法，加入新的规则或限定条件来完善。

Y将所有字符派上去，X依然是2个字符，经仔细观察，还是填2.

看五行，X再多派一个C，ABC的子序列集合比AB的子序列集合大一些，那么它与Y的B子序列集合大一些，就算不大，就不能比原来的小。显然新增的C不能成为战力，不是两者的公共字符，因此值应该等于AB的子序列集合。

×""BDCABA
""0000000
A0000111
B0111122
C01




D0





A0





B0





并且我们可以确定，如果两个字符串要比较的字符不一样，那么要填的格子是与其左边或上边有关，那边大就取那个。

如果比较的字符一样呢，稍安毋躁，刚好X的C要与Y的C进行比较，即ABC的子序列集合{"",A,B,C,AB,BC,ABC}与BDC的子序列集合｛"",B,D,C,BD,DC,BDC｝比较，得到公共子串有“”,B,D 。这时还是与之前的结论一样，当字符相等时，它对应的格子值等于左边与右边与左上角的值，并且左边，上边，左上边总是相等的。这些奥秘需要更严格的数学知识来论证。

假设有两个数组，A和B。A[i]为A的第i个元素，A(i)为由A的第一个元素到第i个元素所组成的前缀。m(i, j)为A(i)和B(j)的最长公共子序列长度。
由于算法本身的递推性质，其实只要证明，对于某个i和j： m(i, j) = m(i-1, j-1) + 1 （当A[i] = B[j]时） m(i, j) = max( m(i-1, j), m(i, j-1) ) （当A[i] != B[j]时） 第一个式子很好证明，即当A[i] = B[j]时。可以用反证，假设m(i, j) > m(i-1, j-1) + 1 （m(i, j)不可能小于m(i-1, j-1) + 1，原因很明显），那么可以推出m(i-1, j-1)不是最长的这一矛盾结果。 第二个有些trick。当A[i] != B[j]时，还是反证，假设m(i, j) > max( m(i-1, j), m(i, j-1) )。 由反证假设，可得m(i, j) > m(i-1, j)。这个可以推出A[i]一定在m(i, j)对应的LCS序列中（反证可得）。而由于A[i] != B[j]，故B[j]一定不在m(i, j)对应的LCS序列中。所以可推出m(i, j) = m(i, j-1)。这就推出了与反正假设矛盾的结果。 得证。

我们现在用下面的方程来继续填表了。

程序实现
  
  
  1. //by 司徒正美
  2. function LCS(str1, str2){
  3.         var rows =  str1.split("")
  4.         rows.unshift("")
  5.         var cols =  str2.split("")
  6.         cols.unshift("")
  7.         var m = rows.length 
  8.         var n = cols.length 
  9.         var dp = []
  10.         for(var i = 0; i < m; i++){ 
  11.             dp[i] = []
  12.             for(var j = 0; j < n; j++){ 
  13.                 if(i === 0 || j === 0){
  14.                     dp[i][j] = 0
  15.                     continue
  16.                 }
  18.                 if(rows[i] === cols[j]){ 
  19.                     dp[i][j] = dp[i-1][j-1] + 1 //对角＋1
  20.                 }else{
  21.                     dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) //对左边，上边取最大
  22.                 }
  23.             }
  24.             console.log(dp[i].join(""))//调试
  25.         } 
  26.         return dp[i-1][j-1]
  27.     }

LCS可以进一步简化，只要通过挪位置，省去新数组的生成。

  
  
  1. //by司徒正美
  2. function LCS(str1, str2){
  3.     var m = str1.length 
  4.     var n = str2.length
  5.     var dp = [new Array(n+1).fill(0)] //第一行全是0
  6.     for(var i = 1; i <= m; i++){ //一共有m+1行
  7.         dp[i] = [0] //第一列全是0
  8.         for(var j = 1; j <= n; j++){//一共有n+1列
  9.             if(str1[i-1] === str2[j-1]){ 
  10.                 //注意这里，str1的第一个字符是在第二列中，因此要减1，str2同理
  11.                 dp[i][j] = dp[i-1][j-1] + 1 //对角＋1
  12.             } else {
  13.                  dp[i][j] = Math.max( dp[i-1][j], dp[i][j-1]) 
  14.             }
  15.         }
  16.     } 
  17.     return dp[m][n];
  18. }
打印一个LCS

我们再给出打印函数，先看如何打印一个。我们从右下角开始寻找，一直找到最上一行终止。因此目标字符串的构建是倒序。为了避免使用stringBuffer这样麻烦的中间量，我们可以通过递归实现，每次执行程序时，只返回一个字符串，没有则返回一个空字符串， 以 printLCS(x,y,...)+str[i]相加，就可以得到我们要求的字符串。

我们再写出一个方法，来验证我们得到的字符串是否真正的LCS字符串。作为一个已经工作的人，不能写的代码像在校生那样，不做单元测试就放到线上让别人踩坑。

  
  
  1. //by 司徒正美，打印一个LCS
  2. function printLCS(dp, str1, str2, i, j){
  3.     if (i == 0 || j == 0){
  4.         return "";
  5.     }
  6.     if( str1[i-1] == str2[j-1] ){
  7.         return printLCS(dp, str1, str2, i-1, j-1) + str1[i-1];
  8.     }else{
  9.         if (dp[i][j-1] > dp[i-1][j]){
  10.             return printLCS(dp, str1, str2, i, j-1);
  11.         }else{
  12.             return printLCS(dp, str1, str2, i-1, j);
  13.         }
  14.     }
  15. }
  16. //by司徒正美， 将目标字符串转换成正则，验证是否为之前两个字符串的LCS
  17. function validateLCS(el, str1, str2){
  18.    var re =  new RegExp( el.split("").join(".*") )
  19.    console.log(el, re.test(str1),re.test(str2))
  20.    return re.test(str1) && re.test(str2)
  21. }

使用：

  
  
  1. function LCS(str1, str2){
  2.     var m = str1.length 
  3.     var n = str2.length
  4.     //....略，自行补充
  5.     var s = printLCS(dp, str1, str2, m, n)
  6.     validateLCS(s, str1, str2)
  7.     return dp[m][n]
  8. }
  9. var c1 = LCS( "ABCBDAB","BDCABA");
  10. console.log(c1) //4 BCBA、BCAB、BDAB
  11. var c2 = LCS("13456778" , "357486782" );
  12. console.log(c2) //5 34678 
  13. var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );
  14. console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

打印全部LCS

思路与上面差不多，我们注意一下，在LCS方法有一个Math.max取值，这其实是整合了三种情况，因此可以分叉出三个字符串。我们的方法将返回一个es6集合对象，方便自动去掉。然后每次都用新的集合合并旧的集合的字任串。

  
  
  1. //by 司徒正美 打印所有LCS
  2. function printAllLCS(dp, str1, str2, i, j){
  3.     if (i == 0 || j == 0){
  4.         return new Set([""])
  5.     }else if(str1[i-1] == str2[j-1]){
  6.         var newSet = new Set()
  7.         printAllLCS(dp, str1, str2, i-1, j-1).forEach(function(el){
  8.             newSet.add(el + str1[i-1])
  9.         })
  10.         return newSet
  11.     }else{
  12.         var set = new Set()
  13.         if (dp[i][j-1] >= dp[i-1][j]){
  14.             printAllLCS(dp, str1, str2, i, j-1).forEach(function(el){
  15.               set.add(el)
  16.             })
  17.         }
  18.         if (dp[i-1][j] >= dp[i][j-1]){//必须用>=，不能简单一个else搞定
  19.             printAllLCS(dp, str1, str2, i-1, j).forEach(function(el){
  20.               set.add(el)
  21.             })
  22.         }   
  23.         return set
  24.     } 
  25.  }

使用：

  
  
  1. function LCS(str1, str2){
  2.     var m = str1.length 
  3.     var n = str2.length
  4.     //....略，自行补充
  5.     var s =  printAllLCS(dp, str1, str2, m, n)
  6.     console.log(s)
  7.     s.forEach(function(el){
  8.         validateLCS(el,str1, str2)
  9.         console.log("输出LCS",el)
  10.     })
  11.     return dp[m][n]
  12. }
  13. var c1 = LCS( "ABCBDAB","BDCABA");
  14. console.log(c1) //4 BCBA、BCAB、BDAB
  15. var c2 = LCS("13456778" , "357486782" );
  16. console.log(c2) //5 34678 
  17. var c3 = LCS("ACCGGTCGAGTGCGCGGAAGCCGGCCGAA" ,"GTCGTTCGGAATGCCGTTGCTCTGTAAA" );
  18. console.log(c3) //20 GTCGTCGGAAGCCGGCCGAA

空间优化

使用滚动数组：

  
  
  1. function LCS(str1, str2){
  2.     var m = str1.length 
  3.     var n = str2.length
  4.     var dp = [new Array(n+1).fill(0)],now = 1，row //第一行全是0
  5.     for(var i = 1; i <= m; i++){ //一共有2行
  6.         row = dp[now] = [0] //第一列全是0
  7.         for(var j = 1; j <= n; j++){//一共有n+1列
  8.             if(str1[i-1] === str2[j-1]){ 
  9.                 //注意这里，str1的第一个字符是在第二列中，因此要减1，str2同理
  10.                 dp[now][j] = dp[i-now][j-1] + 1 //对角＋1
  11.             } else {
  12.                 dp[now][j] = Math.max( dp[i-now][j], dp[now][j-1]) 
  13.             }
  14.         }
  15.         now = 1- now; //1-1=>0;1-0=>1; 1-1=>0 ...
  16.     } 
  17.     return row ? row[n]: 0
  18. }
危险的递归解法

str1的一个子序列相应于下标序列{1, 2, …, m}的一个子序列，因此，str1共有${2^m}$个不同子序列（str2亦如此，如为${2^n}$），因此复杂度达到惊人的指数时间（${2^m * 2^n}$）。

  
  
  1. //警告，字符串的长度一大就会爆栈
  2. function LCS(str1, str2, a, b) {
  3.       if(a === void 0){
  4.           a = str1.length - 1
  5.       }
  6.       if(b === void 0){
  7.           b = str2.length - 1
  8.       }
  9.       if(a == -1 || b == -1){
  10.           return 0
  11.       } 
  12.       if(str1[a] == str2[b]) {
  13.          return LCS(str1, str2,  a-1, b-1)+1;
  14.       }
  15.       if(str1[a] != str2[b]) {
  16.          var x =  LCS(str1, str2, a, b-1)
  17.          var y =  LCS(str1, str2, a-1, b)
  18.          return x >= y ? x : y
  19.       }
  20.   }
参考链接

  1. http://blog.csdn.net/hrn1216/article/details/51534607

  2. https://segmentfault.com/a/1190000002641054

  3. https://www.cnblogs.com/ider/p/longest-common-substring-problem-optimization.html

  4. http://www.cppblog.com/mysileng/archive/2013/05/14/200265.html



觉得本文对你有帮助？请分享给更多人

关注「前端大全」，提升前端技能

前端大全
关注
JavaScript:实现最长公共子序列算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-22 211
JavaScript:实现最长公共子序列算法（附完整源码）
js最长公共子序列
mus-z的博客
08-10 873
首先初始化一个(m+1)X(n+1)的二维数组，从(1,1)开始遍历 如果i==j，则按照左上方对角线连接当前字符形成新的最长公共子序列 如果不相等就判断左方和上方哪个长用哪个 遍历结束之后最右下角就是我们需要的字串了 function lcs(wordX, wordY) { let m = wordX.length; let n = wordY.length; let solution = []; //初始化一个二维数组，长度宽度分别为两个字符串的长度+1,内容为动态规划当前两分串的最长公
javascript 最长公共子序列
weixin_33694620的博客
01-16 369
最长公共子序列（Longest Common Subsequence LCS）是从给定的两个序列X和Y中取出尽可能多的一部分字符，按照它们在原序列排列的先后次序排列得到。LCS问题的算法用途广泛，如在软件不同版本的管理中，用LCS算法找到新旧版本的异同处;在软件测试中，用LCS算法对录制和回放的序列进行比较，在基因工程领域，用LCS算法检...
leetcode 1143.最长公共子序列 (动态规划)
qq_29762941的博客
10-10 651
给定两个字符串text1 和text2，返回这两个字符串的最长公共子序列。 一个字符串的子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是 "abcde" 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。 若这两个字...
基于node.js实现最长公共子序列算法.zip
最新发布
05-10
项目中的源代码很可能会包含一个名为"基于node.js实现最长公共子序列算法"的文件，其中展示了如何在Node.js环境中用JavaScript编写这个算法的详细过程。代码可能包括定义函数、创建dp数组、遍历和计算的过程，以及...
javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip
03-16
本压缩包文件“javascript-leetcode面试题解动态规划问题之第1143题最长公共子序列-题解.zip”包含了关于动态规划解决方案的详细解析，这是一道典型的算法面试题。 动态规划是一种解决复杂问题的有效方法，它通过将...
js代码-最长公共子序列
07-15
最长公共子序列（Longest Common Subsequence，LCS）是计算机科学中一种经典的字符串问题，主要应用于比较和分析两个或多个序列的相似性。在JavaScript编程中，解决这个问题可以帮助我们处理文本编辑、生物信息学、...
JavaScript实现求最大公共子串的方法
10-18
主要介绍了JavaScript实现求最大公共子串的方法,涉及javascript针对字符串的遍历、匹配、运算等相关操作技巧,需要的朋友可以参考下
JavaScript自定义函数实现查找两个字符串最长公共子串的方法
01-19
本文实例讲述了JavaScript自定义函数实现查找两个字符串最长公共子串的方法。分享给大家供大家参考，具体如下： //查找两个字符串的最长公共子串 function findSubStr(s1,s2){ var S=sstr= ,L1=s1.length,L2=s2.length; if (L1>L2){ var s3=s1;s1=s2,s2=s3,L1=s2.length;} for ( var j=L1;j> 0 ;j--) for ( var i= 0 ;i<=L1-j;i++){ sstr = s1.substr(i,j); if
Js -- 最长公共子串（算法）
夜神、
08-31 2645
先比较s1、s2的长度，如果是s1比s2长则交换位置取较短的字符串作为。substr(idex, len)，所以拿较短的串取其子串，然后判断它是否在较长的字符串中存在，如果存中则直接返回，否则再取下一位。 const findSubStr = (str1, str2) => { if (str1.length > str2.length) { [str1, str2] = [str2, str1] } let result = ""; const len = str1.l
JavaScript动态规划实现最长公共子序列
zzqworkspace的博客
04-13 783
最大公共子序列是动态规划中非常经典的例子，其规则是找出两个数组序列中顺序相同但不一定连续、最长的公共子序列 我们用JavaScript来实现它： var c=new Array(20),b=new Array(20); for (var i=0,len=c.length>b.length?c.length:b.length;i<len;i++) { c[i]=new Array
js 实现 动态规划算法之：最长公共子序列
weixin_33973609的博客
05-27 535
一道常见的前端面试题 原理是动态规划 找了一篇博客来讲解这个部分，不过用Java实现的 原址在： https://my.oschina.net/leejun2005/blog/117167 /////////////////////复制他人博客部分///////////////////////// 利用矩阵来保存子串数量信息 1、先科普下最长公共子序列 & 最长公共子串的区别： 找两个字符...
算法题-最长公共子序列【JS实现】
CrystalLee
03-23 508
https://leetcode-cn.com/problems/longest-common-subsequence/ 给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。 一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。 例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的「公共子序列」是这两个字符串所共同拥有的子序列。
1143. 最长公共子序列 JavaScript实现
weixin_43466639的博客
05-24 336
1143. 最长公共子序列 题目链接 一、思想 – 动态规划 1、二维dp数组 dp[i] [j]：长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列. （i , j用来遍历两个字符串的指针） 2、状态转移方程 主要就是两大情况： text1[i - 1] 与 text2[j - 1]相同，text1[i - 1] 与 text2[j - 1]不相同。（这里比较的就是是否存在共同元素，不特指哪个元素。之所以是i-1，是为了因为是从1开始遍历，i-1表示
javascript写算法（一） 动态规划：最长公共子序列
凝视深渊
03-26 2991
csdn是疯了吗，是baidu算出来的广告嵌在了iframe里，fixed to viewport，之前一直用的c++写算法，在std的基础上javascript的“人造性”更强，比如数组和字符串都有很多自带的function，而且有一种不拘于数据类型的灵活性。写算法的话，网上的提交工具许多是用node 中readline javascript实现最长公共子序列 动态规划
HUAWEI 机试题：最长连续子序
weixin_47243236的博客
02-14 3302
???? Scala 实现 题目描述： 有N个正整数组成的一个序列，给定一个整数sum 求长度最长的的连续子序列使他们的和等于sum 返回次子序列的长度，如果没有满足要求的序列 返回-1 备注： 输入序列仅由数字和英文逗号构成，数字之间采用英文逗号分割 序列长度 1<=N<=200，输入序列不考虑异常情况 由题目保证输入序列满足要求 示例 输入： 1,2,3,4,2 6 输出： 3 解析： 1,2,3和4,2两个序列均能满足要求，所以最长的连续序列为1,2,3 因此结果为
详解动态规划最长公共子序列--JavaScript实现
weixin_34032792的博客
05-28 305
前面两篇我们讲解了01背包问题和最少硬币找零问题。这篇将介绍另一个经典的动态规划问题--最长公共子序列。如果没看过前两篇，可点击下面链接。 详解动态规划最少硬币找零问题--JavaScript实现 详解动态规划01背包问题--JavaScript实现 问题 给定两个字符串序列 abcadf , acbad，求这两个字符串的最长公共子序列 分析 最长公共子序列问题，有三个点需要注意 两个序列长...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值