最长公共子串、最长公共子序列、字符串编辑距离

最新推荐文章于 2021-09-24 21:44:05 发布
最新推荐文章于 2021-09-24 21:44:05 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构与算法分析
本文深入探讨了最长公共子串、最长公共子序列和字符串编辑距离的概念与算法实现，包括动态规划、后缀数组等多种方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章出自：http://dsqiu.iteye.com/blog/1701541

最长公共子串、最长公共子序列、字符串编辑距离

 

最长公共子串

 

问题描述

如果字符串一的所有字符按其在字符串中的顺序出现在另外一个字符串二中，则字符串一称之为字符串二的子串。注意，并不要求子串（字符串一）的字符必须连续出现在字符串二中。

基本方法

大凡基本方法都是枚举方法，这里其实就枚举所有长度相等的子串进行比较。枚举方法时没有考虑一切实际情况的，这样就有很多“漏洞”，就可以有很多优化的方法。

 

动态规划

╔

使用dp[i][j]表示 以x[i]和y[j]结尾的最长公共子串的长度，因为要求子串连续，所以对于X[i]与Y[j]来讲，它们要么与之前的公共子串构成新的公共子串；要么就是不构成公共子串。故状态转移方程 X[i] == Y[j]，dp[i][j] = dp[i-1][j-1] + 1 X[i] != Y[j]，dp[i][j] = 0 对于初始化，i==0或者j==0，如果X[i] == Y[j]，dp[i][j] = 1；否则dp[i][j] = 0。这样的处理跟连续子数组最大和有点类似，只是连续子数组子和是当dp[i]<0时执行dp[i]=0。

 

C代码   收藏代码
  1. /* 最长公共子串 DP */  
  2. int dp[30][30];  
  3.    
  4. void LCS_dp(char * X, int xlen, char * Y, int ylen)  
  5. {  
  6.     maxlen = maxindex = 0;  
  7.     for(int i = 0; i < xlen; ++i)  
  8.     {  
  9.         for(int j = 0; j < ylen; ++j)  
  10.         {  
  11.             if(X[i] == Y[j])  
  12.             {  
  13.                 if(i && j)  
  14.                 {  
  15.                     dp[i][j] = dp[i-1][j-1] + 1;  
  16.                 }  
  17.                 if(i == 0 || j == 0)  
  18.                 {  
  19.                     dp[i][j] = 1;  
  20.                 }  
  21.                 if(dp[i][j] > maxlen)  
  22.                 {  
  23.                     maxlen = dp[i][j];  
  24.                     maxindex = i + 1 - maxlen;  
  25.                 }  
  26.             }  
  27.         }  
  28.     }  
  29.     outputLCS(X);  
  30. }  

 

后缀数组求解

后缀数组在前面的博文有介绍， 如果将两个字符串连接起来成新字符串，最长公共子串问题就转化为新字符串的最长重复子串的问题（点击前往）了，唯一的区别就是要区别来着同一个字符的最大重复子串。

这里就不在列举了，在处理过程中要对后缀数组进行排序操作，可以考虑重后缀子串的长度的影响——公共子串的长度一定是相等的。

时间复杂度分析

对于基本算法，X的子串（m个）和Y的子串（n个）一一对比，最坏情况下，复杂度为O(m*n*l)，空间复杂度为O(1)。

对于动态规划算法，由于自底向上构建最优子问题的解，时间复杂度为O(m*n)；空间复杂度为O(m*n)，当然这里是可以使用滚动数组来优化空间的，滚动数组在动态规划基础回顾中多次提到。 对于后缀数组方法，连接到一起并初始化后缀数组的时间复杂度为O(m+n)，

对后缀数组的字符串排序，由于后缀数组有m+n个后缀子串，子串间比较，故复杂度为O((m+n)*l*lg(m+n))，求得最长子串遍历后缀数组，复杂度为O(m+n)，所以总的时间复杂度为O((m+n)*l*lg(m+n))，空间复杂度为O(m+n)。 总的来说使用后缀数组对数据做一些“预处理”，在效率上还是能提升不少的。

╝①

 

最长公共子序列

 

问题描述

╔

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

动态规划求解

使用动态规划求解这个问题，先寻找最优子结构。设X=<x1,x2,…,xm>和Y=<y1,y2,…,yn>为两个序列，LCS(X,Y)表示X和Y的一个最长公共子序列，可以看出

  1. 如果xm=yn，则LCS ( X,Y ) = xm + LCS ( Xm-1,Yn-1 )。
  2. 如果xm!=yn，则LCS( X,Y )= max{ LCS ( Xm-1, Y ), LCS ( X, Yn-1 ) }

LCS问题也具有重叠子问题性质：为找出X和Y的一个LCS，可能需要找X和Yn-1的一个LCS以及Xm-1和Y的一个LCS。但这两个子问题都包含着找Xm-1和Yn-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=0dp[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的最优方案了，既可以用一个额外的矩阵存储路径，也可以直接根据状态转移矩阵倒推最优方案。

 

Cpp代码   收藏代码
  1. #include <iostream>  
  2. using namespace std;  
  3.    
  4. /* LCS 
  5.  * 设序列长度都不超过20 
  6. */  
  7.    
  8. int dp[21][21]; /* 存储LCS长度, 下标i,j表示序列X,Y长度 */  
  9. char X[21];  
  10. char Y[21];  
  11. int i, j;  
  12.    
  13. void main()  
  14. {  
  15.     cin.getline(X,20);  
  16.     cin.getline(Y,20);  
  17.    
  18.     int xlen = strlen(X);  
  19.     int ylen = strlen(Y);  
  20.    
  21.     /* dp[0-xlen][0] & dp[0][0-ylen] 都已初始化0 */  
  22.     for(i = 1; i <= xlen; ++i)  
  23.     {  
  24.         for(j = 1; j <= ylen; ++j)  
  25.         {  
  26.             if(X[i-1] == Y[j-1])  
  27.             {  
  28.                 dp[i][j] = dp[i-1][j-1] + 1;  
  29.             }else if(dp[i][j-1] > dp[i-1][j])  
  30.             {  
  31.                 dp[i][j] = dp[i][j-1];  
  32.             }else  
  33.             {  
  34.                 dp[i][j] = dp[i-1][j];  
  35.             }  
  36.         }  
  37.     }  
  38.     printf("len of LCS is: %d\n", dp[xlen][ylen]);  
  39.    
  40.     /* 输出LCS 本来是逆序打印的，可以写一递归函数完成正序打印 
  41.        这里采用的方法是将Y作为临时存储LCS的数组，最后输出Y 
  42.     */  
  43. i = xlen;  
  44. j = ylen;  
  45. int k = dp[i][j];  
  46. char lcs[21] = {'\0'};  
  47. while(i && j)  
  48. {  
  49.   
  50.     if(X[i-1] == Y[j-1] && dp[i][j] == dp[i-1][j-1] + 1)  
  51.   
  52.     {  
  53.   
  54.         lcs[--k] = X[i-1];  
  55.   
  56.         --i; --j;  
  57.   
  58.     }else if(X[i-1] != Y[j-1] && dp[i-1][j] > dp[i][j-1])  
  59.   
  60.     {  
  61.   
  62.         --i;  
  63.   
  64.     }else  
  65.   
  66.     {  
  67.   
  68.         --j;  
  69.   
  70.     }  
  71. }  
  72. printf("%s\n",lcs);  
  73.   
  74. }  
 

 

 

Cpp代码   收藏代码
  1.   

  在LCS问题中，如果仅仅要求求出LCS的长度，而不要求输出序列，那么由于每步迭代都只用到了前面的状态，之前的信息便无用了，就可以使用滚动数组了。

 

Cpp代码   收藏代码
  1. #include <iostream>  
  2. using namespace std;  
  3.    
  4. /* 滚动数组 */  
  5.    
  6. int dp[2][21];  /* 存储LCS长度 */  
  7. char X[21];  
  8. char Y[21];  
  9. int i, j, k;  
  10.    
  11. void main()  
  12. {  
  13.     cin.getline(X,20);  
  14.     cin.getline(Y,20);  
  15.    
  16.     int xlen = strlen(X);  
  17.     int ylen = strlen(Y);  
  18.    
  19.     for(i = 1; i <= xlen; ++i)  
  20.     {  
  21.         k = i & 1;  
  22.         for(j = 1; j <= ylen; ++j)  
  23.         {  
  24.             if(X[i-1] == Y[j-1])  
  25.             {  
  26.                 dp[k][j] = dp[k^1][j-1] + 1;  
  27.             }else if(dp[k][j-1] > dp[k^1][j])  
  28.             {  
  29.                 dp[k][j] = dp[k][j-1];  
  30.             }else  
  31.             {  
  32.                 dp[k][j] = dp[k^1][j];  
  33.             }  
  34.         }  
  35.     }  
  36.     printf("len of LCS is: %d\n", dp[k][ylen]);  
  37. }  

╝②

 

字符串编辑距离

 

问题描述

╔

字符串编辑距离又叫字符串相似度，编辑距离就是将两个不同的字符串变成相同字符串所需要操作的次数的最小值。而这些操作只有以下三种：

1)修改一个字符

2)增加一个字符

3)删除一个字符

 

寻找子问题时，我们完全可以像分析最长公共子序列那样分析这个问题，都是“从后向前”看，假设有两个串X=abcdaex，Y=fdfax，它们的最后一个字符是相同的，只要计算X[1,…,6]=abcdae和Y[1,…,4]=fdfa的距离就可以了；但是如果两个串的最后一个字符不相同，那么就可以进行如下的操作来达到目的（xlen和ylen是X串和Y串的长度）：

 

1.一步操作之后，再计算X[1,…,xlen-1]和Y[1,…ylen]的距离。这个操作可以是删除X的最后一个字符，也可以是增加X串的最后一个字符到Y串的最后字符之后

2.一步操作之后，再计算X[1,…,xlen]和Y[1,…ylen-1]的距离。这个操作与情况1类似，反过来而已

3.一步操作之后，再计算X[1,…,xlen-1]和Y[1,…ylen-1]的距离。这个操作可以是修改X串的最后有一个字符为Y串的最后一个字符，后者修改Y的变为X的最后一个字符，使得二者相同。

 

 

dp[i][j]中的i和j表示串X和Y的长度，其中，如果某一个串的长度为0，则编辑距离就是另一个串的长度，这很容易理解。状态转移方程为

 

1.dp[i][j] = 0  如果i=0 & j=0

2.dp[i][j] = xlen | ylen  如果j=0 | i=0

3.dp[i][j] = dp[i-1][j-1]  如果X[i-1] = Y[i-1]

4.dp[i][j] = 1 + min{ dp[i-1][j], dp[i][j-1], dp[i-1][j-1] }  如果X[i-1] != Y[i-1]

 

下面给出了三种实现方式，第一种是根据分析给出的递归搜索方法；由于具有重叠子问题，所以第二种方法便是使用了备忘录的递归方法（注：分治与动态规划的重要区别就是分治递归不断产生新的子问题，没有重叠子问题；而DP则是在递归不断产生子问题的同时很多子问题是重复计算的，即重叠子问题）；第三种便是根据状态转移方程给出了自底向上的实现，这也是最符合DP性质的实现方式。

简单递归搜索

 

Cpp代码   收藏代码
  1. /* 递归搜索 */  
  2. int calDistance1(char *ptrX, int xbeg, int xend, char *ptrY, int ybeg, int yend)  
  3. {  
  4.     if(xbeg > xend)  
  5.     {  
  6.         if(ybeg > yend)  
  7.             return 0;  
  8.         else  
  9.             return yend - ybeg + 1;  
  10.     }  
  11.     if(ybeg > yend)  
  12.     {  
  13.         if(xbeg > xend)  
  14.             return 0;  
  15.         else  
  16.             return xend - xbeg + 1;  
  17.     }  
  18.     if(ptrX[xend] == ptrY[yend])  
  19.     {  
  20.         return calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);  
  21.     }else  
  22.     {  
  23.         int t1 = calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend);  
  24.         int t2 = calDistance1(ptrX,xbeg,xend,ptrY,ybeg,yend-1);  
  25.         int t3 = calDistance1(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);  
  26.         t1 = t1 < t2 ? t1 : t2;  
  27.         return (t1 < t3 ? t1 : t3) + 1;  
  28.     }  
  29. }  

 

 递归+备忘录

 

Cpp代码   收藏代码
  1. /* 编辑距离 
  2.  * 设每个字符串长度不超过 30 
  3. */  
  4.    
  5. /* 存储子问题的解 i,j表示X，Y长度 
  6.  * dp[i][j]表示X[0-i)与Y[0-j)的编辑距离 
  7. */  
  8. int dp[31][31];  
  9. /* 自顶向下 & 备忘录 */  
  10. int calDistance2(char *ptrX, int xbeg, int xend, char *ptrY, int ybeg, int yend)  
  11. {  
  12.     if(xend == 0)  
  13.     {  
  14.         if(yend == 0)  
  15.             return 0;  
  16.         else  
  17.             return yend - ybeg + 1;  
  18.     }  
  19.     if(yend == 0)  
  20.     {  
  21.         if(xend == 0)  
  22.             return 0;  
  23.         else  
  24.             return xend - xbeg + 1;  
  25.     }  
  26.     if(ptrX[xend-1] == ptrY[yend-1])  
  27.     {  
  28.         if(dp[xend-1][yend-1] == 0)  
  29.         {  
  30.             dp[xend-1][yend-1] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);  
  31.         }  
  32.         return dp[xend-1][yend-1];  
  33.     }else  
  34.     {  
  35.         int t1, t2, t3;  
  36.         if(dp[xend-1][yend] == 0)  
  37.         {  
  38.             dp[xend-1][yend] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend);  
  39.         }  
  40.         t1 = dp[xend-1][yend];  
  41.         if(dp[xend][yend-1] == 0)  
  42.         {  
  43.             dp[xend][yend-1] = calDistance2(ptrX,xbeg,xend,ptrY,ybeg,yend-1);  
  44.         }  
  45.         t2 = dp[xend][yend-1];  
  46.         if(dp[xend-1][yend-1] == 0)  
  47.         {  
  48.             dp[xend-1][yend-1] = calDistance2(ptrX,xbeg,xend-1,ptrY,ybeg,yend-1);  
  49.         }  
  50.         t3 = dp[xend-1][yend-1];  
  51.         t1 = t1 < t2 ? t1 : t2;  
  52.         return (t1 < t3 ? t1 : t3) + 1;  
  53.     }  
  54. }  

 

自底向上动态规划

Cpp代码   收藏代码
  1. /* 编辑距离 
  2.  * 设每个字符串长度不超过 30 
  3. */  
  4.    
  5. /* 存储子问题的解 i,j表示X，Y长度 
  6.  * dp[i][j]表示X[0-i)与Y[0-j)的编辑距离 
  7. */  
  8. int dp[31][31];  
  9. char X[31];  
  10. char Y[31];  
  11. /* 自底向上 DP */  
  12. int calDistance3(char *ptrX, int xlen, char *ptrY, int ylen)  
  13. {  
  14.     int i, j;  
  15.     for(i = 1; i <= xlen; ++i)  
  16.     {  
  17.         dp[i][0] = i;  
  18.     }  
  19.     for(j = 1; j <= ylen; ++j)  
  20.     {  
  21.         dp[0][j] = j;  
  22.     }  
  23.     for(i = 1; i <= xlen; ++i)  
  24.     {  
  25.         for(j = 1; j <= ylen; ++j)  
  26.         {  
  27.             if(ptrX[i-1] == ptrY[j-1])  
  28.             {  
  29.                 dp[i][j] = dp[i-1][j-1];  
  30.             }else  
  31.             {  
  32.                 int t1 = dp[i-1][j];  
  33.                 t1 = t1 < dp[i][j-1] ? t1 :dp[i][j-1];  
  34.                 t1 = t1 < dp[i-1][j-1] ? t1 : dp[i-1][j-1];  
  35.                 dp[i][j] = t1 + 1;  
  36.             }  
  37.         }  
  38.     }  
  39.     return dp[xlen][ylen];  
  40. }  

一并给出测试用例

Cpp代码   收藏代码
  1. #include <iostream>  
  2. using namespace std;  
  3. void main()  
  4. {  
  5.     cin.getline(X,30);  
  6.     cin.getline(Y,30);  
  7.    
  8.     int xlen = strlen(X);  
  9.     int ylen = strlen(Y);  
  10.    
  11.     printf("%d\n",calDistance1(X,0,xlen-1,Y,0,ylen-1));  
  12.     //printf("%d\n",calDistance2(X,0,xlen,Y,0,ylen));  
  13.     printf("%d\n",calDistance3(X,xlen,Y,ylen));  
  14. }  

╝③   

 

 

参考：

①勇幸|Thinking：http://www.ahathinking.com/archives/122.html

②勇幸|Thinking：http://www.ahathinking.com/archives/115.html

③勇幸|Thinking：http://www.ahathinking.com/archives/116.html

 


动态规划经典问题 - 求最长公共子串 / 公共子序列
chenyao的博客~
05-24 1849
首先要理解公共子串和公共子序列 公共子串和公共子序列是两个不相同的概念, 公共子串要求字符连续, 公共子序列不要求字符连续。 比如: 字符串"ascde", “axcxdde” 最长公共子串是 “de” , 因为 "de"在两个字符串中都是连续的 最长公共子序列是 “acde”, 不要求连续, 只要满足两个字符串中子序列前后顺序的一致即可 动态规划求最长公共子序列 动态规划的核心是 base case 状态转移方程 自下而上 我们可以通过状态转移表来帮助我们得出状态转移方程 这里我直接说结论: 我们思考
最大子序列、最长递增子序列、最长公共子串、最长公共子序列、字符串编辑距离总结
小拳头的博客
11-20 1521
一、最长公共子串和最长公共子序列 最长公共子串（Longest Common Substring）是串的一个连续的部分。最长公共子序列（Longest Common Subsequence，LCS）是不一定是连续的，但是不改变序列中元素在原串中的相对顺序，而是从序列中去掉任意的元素而获得新的序列。也就是说，子串中字符的位置必须是连续的，子序列则可以不连续。   二、思想 采用动态规划的思想
编辑距离与最长公共子串（字符串的相似度）
05-23
用本程序可得到字符串的相似度和字符串的公共子串以及编辑距离。
最大子序列、最长递增子序列、最长公共子串、最长公共子序列、字符串编辑距离...
weixin_33964094的博客
04-11 257
最大子序列 最大子序列是要找出由数组成的一维数组中和最大的连续子序列。比如{5,-3,4,2}的最大子序列就是 {5,-3,4,2}，它的和是8,达到最大；而 {5,-6,4,2}的最大子序列是{4,2}，它的和是6。你已经看出来了，找最大子序列的方法很简单，只要前i项的和还没有小于0那么子序列就一直向后扩展，否则丢弃之前的子序列开始新的子序列，同时我们要记下各个子序列的和，最后找到和最大的子序...
最长公共子串，编辑距离，最长公共子序列
Hello_Ray的博客
04-20 710
最长公共子序列，编辑距离，最长公共串 最长公共子序列，编辑距离，最长公共串求文本的相似度与向量夹角求文本的相似度
编辑距离，最长公共子序列，最长公共子串，最长递增子序列
weixin_33973600的博客
06-21 182
1.编辑距离 编辑距离，又称Levenshtein距离（也叫做Edit Distance），是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念。 例如将kitten一字转成sitting： sitten （k→s） sittin ...
找工作知识储备(2)---数组字符串那些经典算法：最大子序列和，最长递增子序列，最长公共子串，最长公共子序列，字符串编辑距离，最长不重复子串，最长回文子串
热门推荐
寒小阳
09-24 2万+
0、前言         这一部分的内容原本是打算在之后的字符串或者数组专题里面写的，但看着目前火热进行的各家互联网公司笔试面试中，出现了其中的一两个内容，就随即将这些经典问题整理整理，单写一篇发上来了。这里争取覆盖面广一些，列举了7个最经典的问题，也会是之后大家笔试面试常见到的问题，而每个问题下都列举了几种思路，掌握这些经典问题的解题思路和算法相信对同类型问题的解答都能有帮助。
字符串的最长公共子序列
zhangqiang180的博客
08-21 1340
审题 最长公共子序列（Longest Common Subsequence，简称 LCS）是一道非常经典的面试题目，因为它的解法是典型的二维动态规划，大部分比较困难的字符串问题都和这个问题一个套路，比如说编辑距离。而且，这个算法稍加改造就可以用于解决其他问题，所以说LCS算法是值得掌握的。 所谓子序列，就是要保留原始顺序，但可以是不连续的。审题之后你可能会有疑问，这个问题为啥就是动态规划来解决呢？因为子序列类型的问题，穷举出所有可能的结果都不容易，而动态规划算法做的就是穷举 + 剪枝，它俩天生一对儿。所以可
最大公共字符串，最大公共子序列，编辑距离，myers等算法
Chen_Meng_的博客
09-24 1572
前言 这个4个算法比较相似，并且有以下相同点和不同点 异同点 相同点: 1、都是在字符串上得到某个目标；2、算法的核心都是动态规划的思想。 不同点: 1、目标不同，其中最大公共字符串是最大连续的子序列，例如：str1 = "ABCDEF" , str2="ZABCDZE"，最大公共字符串是"ABCD"，长度为4。而最大公共子序列是"ABCDE"，长度为5。 2、编辑距离，是求从一个字符串str1到另一个字符串str2的变动的最小次数，其中变动只在一个字符串上发生，变动包括三个动作：删除，插入.
求N个字符串的最大公共子串
09-16
求最长的公共子串 求N个字符串的最长公共子串，N＜20，字符串长度不超过255。例如N＝3，由键盘依次输入3个字符串为 Whatislocalbus？ Namesomelocalbuses. loca1busisahighspeedI/Obusclosetotheprocessor. 则最长公共子串为“localbus”。
【专题】编辑距离/最长公共子序列/最长公共子数组
AgoniAngel
03-24 461
两个字符串a和b，长度相等，并且只有A和T两种字符。通过2种操作把a变成b，求最少操作次数。 第1种操作，替换一个字符 第2种操作，交换两个字符的位置 示例： 输入： TAAATT AATTAA 输出： 3 解释： 把第1个字符T替换为A，第3、5个字符交换，第4、6个字符交换。 来自360笔试（2020.3.24） 【思路】这题类似于编辑距离，但操作不同，总体要简单些，不需要...
最长公共子序列、最长公共子串、最小编辑距离三种算法总结
dengyinyi1166的博客
03-11 559
　　最长公共子序列、最长公共子串、最小编辑距离是三种常见的字符串比较算法，考虑到其中的动态规划思想、状态转移方程比较类似，实现的方法也是如出一辙，这里将其状态转移方程和相应的实现代码做一个总结。 1、最长公共子序列（longest common sequence） 　　状态转移方程： 　　实现代码： 1 int LCSeq(string str1, string str...
字符串算法：最长公共子序列、最短编辑距离等
沉浸如海
10-07 1531
最长公共子序列 编辑距离 最长递增子序列等
编辑距离与最长公共子序列总结
我的代码小说
12-04 1997
前言： 其实编辑距离和最长公共子序列是对同一个问题的描述，都能够显示出两个字符串之间的“相似度”，即它们的雷同程度。而子序列与字串的区别在于字串是连续的，子序列可以不连续，只要下标以此递增就行。   编辑距离： Problem description:   设A 和B 是2 个字符串。要用最少的字符操作将字符串A 转换为字符串B。这里所说的字符操作包括 (1)删除一个字符； (2)插入一
数据结构与算法：42 | 动态规划实战：编辑距离与最长公共子序列
zj
08-13 777
文章目录如何量化两个字符串的相似程度如何编程计算莱文斯特距离？如何编程计算最长公共子串长度 在Trie 树那节我们讲过，利用 Trie 树，可以实现搜索引擎的关键词提示功能，可以节省用户输入搜索关键词的时间。实际上，搜索引擎在用户体验方面的优化还有很多，比如常用的拼写纠错功能。 当在搜索框中不小心输错单词时，搜索引擎会非常智能地检测出拼写错误，并且用对应的正确单词来进行搜索。作为一名软件开发工程师，你是否想过，这个功能是怎么实现的呢？ 如何量化两个字符串的相似程度 如何量化两个字符串之间的相似程度呢？有一个
最长公共子序列LCS和字符串编辑距离
hustsselbj的专栏
08-17 1706
最长公共子序列问题是求两个字符串中出现的出现的相同的有先后次序的字符集合（可以不连续），连续的公共子序列是公共子串问题。参考 http://www.cnblogs.com/huangxincheng/archive/2012/11/11/2764625.html 解决方案是动态规划算法，明白递推公式即可快速写出代码，动态规划算法就是解决子问题重叠的场景，不断利用子问题的最优解，所以一般会用到辅助
动态规划之最长公共子序列和编辑距离
Talk is cheap,show me the code!
05-23 2356
1.什么是动态规划
多个字符串的最长公共字串
幽兰止水
10-05 3876
原文链接：http://imlazy.ycool.com/post.1861423.html  如果所有字符串的长度之和是L，则下面介绍的这个算法的平均效率O(L * logL)，但是最坏情况下可能会再乘以O(l)，l是每个字符串的平均长度。     首先对于每个字符串，
最长公共子序列问题和最小编辑距离源码
最新发布
12-03
最长公共子序列（Longest Common Subsequence, LCS）问题是一个经典的计算机科学问题，它涉及到找出两个字符串中最长的共同子序列，即不考虑顺序但保持字符相同的子串。该问题通常用于比较文本相似度，特别是在生物...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值