字符串编辑距离(Levenshtein距离)算法

基本介绍

  Levenshtein距离是一种计算两个字符串间的差异程度的字符串度量(string metric)。我们可以认为Levenshtein距离就是从一个字符串修改到另一个字符串时,其中编辑单个字符(比如修改、插入、删除)所需要的最少次数。俄罗斯科学家Vladimir Levenshtein于1965年提出了这一概念。

简单例子

  从字符串“kitten”修改为字符串“sitting”只需3次单字符编辑操作,如下:

    • sitten ( k -> s )
    • sittin ( e -> i )
    • sitting ( _ -> g )

  因此“kitten”和“sitting”的Levenshtein距离为3。

实现思想

  如何编程实现这一算法呢?许多人试图用矩阵来解释,但实际上矩阵是最终可视化的工具,配合理解“为什么”比较方便,但从矩阵却比较难想到“怎么做”。

  我们试图找到“从字符串$A$修改到字符串$B$”这一问题的子解结构。当然反过来说“从字符串$B$修改到字符串$A$”和它是同一个问题,因为从$A$中删掉一个字符来匹配$B$,就相当于在$B$中插入一个字符来匹配$A$,这两个操作是可以互相转化的。

  假设字符序列$A[1\dots i]$、$B[1\dots j]$分别是字符串$A$、$B$的前$i$、$j$个字符构成的子串,我们得到一个子问题是“从字符串$A[1\dots i]$修改到字符串$B[1\dots j]$”:$$\left[\begin{matrix}\begin{align*}&A:&&A[1]&&A[2]&&\cdots&&A[i-2]&&A[i-1]&&A[i]\\\\&B:&&B[1]&&B[2]&&\cdots&&B[j-2]&&B[j-1]&&B[j]\end{align*}\end{matrix}\right]$$

  ① 插入操作

    • 当将$A[1\dots i]$修改成$B[1\dots j-1]$需要操作数为$op_1$,那么我插入一个字符$A[i‘]=B[i]$到$A[i]$和$A[i+1]$之间,用以匹配$B[i]$,于是$A[1\dots i]$修改到$B[1\dots j]$所需操作数为$op_1+1$。$$\left[\begin{matrix}\begin{align*}&&\cdots&&\color{Red}{A[i-2]}&&\color{Red}{A[i-1]}&&\mathbf{\color{Red}{A[i]}}&&\mathbf{\color{Blue}{A[i‘]}}&&\\\\&&\cdots&&\color{Red}{B[j-2]}&&\mathbf{\color{Red}{B[j-1]}}&&\mathbf{\color{Blue}{B[j]}}&&\phi&&\end{align*}\end{matrix}\right]$$

  ② 删除操作

    • 当将$A[1\dots i-1]$修改成$B[1\dots j]$需要操作数为$op_2$,那么我删掉字符$A[i]$也可以$op_2+1$的操作数使两个子字符串匹配:$$\left[\begin{matrix}\begin{align*}&&\cdots&&\color{Red}{A[i-2]}&&\mathbf{\color{Red}{A[i-1]}}&&\mathbf{\color{Blue}{\phi}}&&\\\\&&\cdots&&\color{Red}{B[j-2]}&&\color{Red}{B[j-1]}&&\mathbf{\color{Red}{B[j]}}&&\end{align*}\end{matrix}\right]$$

  ③ 修改操作

    • 如果$A[1\dots i-1]$修改成$B[1\dots j-1]$所需操作数为$op_3$的话,我将字符$A[i]$替换成$A[i‘]=B[j]$,就可以$op_3+1$的操作数完成:$$\left[\begin{matrix}\begin{align*}&&\cdots&&\color{Red}{A[i-2]}&&\mathbf{\color{Red}{A[i-1]}}&&\mathbf{\color{Blue}{A[i‘]}}&&\\\\&&\cdots&&\color{Red}{B[j-2]}&&\mathbf{\color{Red}{B[j-1]}}&&\mathbf{\color{Blue}{B[j]}}&&\end{align*}\end{matrix}\right]$$
    • 但如果此时字符$A[i]==B[j]$的话,则不需要进行修改操作,操作数仍为$op_3$。

  综上所述,我们将字符串$A[1\dots i]$修改成字符串$B[1\dots j]$所需操作为$min\{op_1+1,\ op_2+1,\ op_3+1_{(a_i\neq b_i)}\}$,其中$1_{(a_i\neq b_i)}$代表当$a_i\neq b_i$时取值$1$,否则取值为$0$。

数学定义

  数学上,我们定义两个字符串$A$和$B$间的Levenshtein距离为$lev_{A,\ B}(a,\ b)$,其中$a$、$b$分别为字符串$A$、$B$的长度,而$$lev_{A,\ B}(i,\ j)=\left\{\begin{matrix}\begin{align*}&i&&,\ j=0\\&j&&,\ i=0\\&min\left\{\begin{matrix}lev_{a,\ b}(i,\ j-1)+1\\lev_{a,\ b}(i-1,\ j)+1\\lev_{a,\ b}(i-1,\ j-1)+1_{(a_i\neq b_i)}\end{matrix}\right.&&,\ otherwise\end{align*}\end{matrix}\right.$$

  更多请参考 Wikipedia - Levenshtein_distance

C++代码

  有了状态转移方程,我们就可以愉快地DP了,时间复杂度$O(MN)$,空间复杂度$O(MN)$。

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <algorithm>
 4 using std::min;
 5 int lena, lenb;
 6 char a[1010], b[1010];
 7 void read() {
 8     scanf("%s%s", a, b);
 9     lena = strlen(a);
10     lenb = strlen(b);
11 }
12
13 int dp[1010][1010];
14 void work() {
15     for(int i=1; i<=lena; i++) dp[i][0] = i;
16     for(int j=1; j<=lenb; j++) dp[0][j] = j;
17     for(int i=1; i<=lena; i++)
18         for(int j=1; j<=lenb; j++)
19             if(a[i-1]==b[j-1])
20                 dp[i][j] = dp[i-1][j-1];
21             else
22                 dp[i][j] = min(dp[i-1][j-1], min(dp[i][j-1], dp[i-1][j]))+1;
23     printf("%d\n", dp[lena][lenb]);
24 }
25
26 int main() {
27     read();
28     work();
29     return 0;
30 }

几个小优化

  1. 如果满足$A[i]==B[j]$(下标从$1$开始),实际上是可以直接取$lev(i,\ j)=lev(i-1,\ j-1)$的。因为此时字符相同是不需要任何编辑操作的。这一优化也可以从上文转移方程中构造不等关系得出。

  2. 如果使用滚动数组,则空间复杂度可以降到$O(2*max\{M,\ N\})$。但也可以通过保存$lev(i-1,\ j-1)$来把空间复杂度降到$O(max\{M,\ N\})$,如下:

 1 int dp[1010];
 2 void work() {
 3     for(int j=1; j<=lenb; j++) dp[j] = j;
 4     int t1, t2;
 5     for(int i=1; i<=lena; i++) {
 6         t1 = dp[0]++;
 7         for(int j=1; j<=lenb; j++) {
 8             t2 = dp[j];
 9             if(a[i-1]==b[j-1])
10                 dp[j] = t1;
11             else
12                 dp[j] = min(t1, min(dp[j-1], dp[j]))+1;
13             t1 = t2;
14         }
15     }
16     printf("%d\n", dp[lenb]);
17 }

以上即为Levenshtein距离算法的基本介绍,如果您喜欢,请点个推荐吧~如果您有宝贵意见,欢迎在下方评论区提出哦~

本文基于知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议发布,欢迎引用、转载或演绎,但是必须保留本文的署名BlackStorm以及本文链接http://www.cnblogs.com/BlackStorm/p/5400809.html,且未经许可不能用于商业目的。如有疑问或授权协商请与我联系。

时间: 2024-11-09 02:38:27

字符串编辑距离(Levenshtein距离)算法的相关文章

java文本相似度计算(Levenshtein Distance算法(中文翻译:编辑距离算法))----代码和详解

算法代码实现: package com.util; public class SimFeatureUtil { private static int min(int one, int two, int three) { int min = one; if (two < min) { min = two; } if (three < min) { min = three; } return min; } public static int ld(String str1, String str2)

Levenshtein Distance莱文斯坦距离算法来计算字符串的相似度

转 理解起来不难,但是很实用. 核心公式就是下面:             (1) 1.百度百科介绍: Levenshtein 距离,又称编辑距离,指的是两个字符串之间,由一个转换成另一个所需的最少编辑操作次数. 许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 编辑距离的算法是首先由俄国科学家Levenshtein提出的,故又叫Levenshtein Distance. 2.用途 模糊查询 3.实现过程 a.首先是有两个字符串,这里写一个简单的 abc和abe b.将

Levenshtein字符串距离算法介绍

Levenshtein字符串距离算法介绍 文/开发部 Dimmacro KMP完全匹配算法和 Levenshtein相似度匹配算法是模糊查找匹配字符串中最经典的算法,配合近期技术栏目关于算法的探讨,上期介绍了KMP算法的一些皮毛,收到了同事的一些反馈,本期再接再厉,搜集了一些资料,简单谈谈Levenshtein相似度匹配算法,希望能抛砖引玉. 算法简介: Levenshtein distance最先是由俄国科学家Vladimir Levenshtein在1965年发明,其原理是两个字符串之间,由

[算法]字符串编辑距离

来自编程之美的一题 许多程序会大量使用字符串.对于不同的字符串,我们希望能够有办法判断其相似程序.我们定义一套操作方法来把两个不相同的字符串变得相同,具体的操作方法为: 1.修改一个字符(如把“a”替换为“b”); 2.增加一个字符(如把“abdd”变为“aebdd”); 3.删除一个字符(如把“travelling”变为“traveling”); 比如,对于“abcdefg”和“abcdef”两个字符串来说,我们认为可以通过增加/减少一个“g”的方式来达到目的.上面的两种方案,都仅需要一 次

51nod 1183 - 编辑距离 - [简单DP][编辑距离问题][Levenshtein距离问题]

题目链接:https://www.51nod.com/onlineJudge/questionCode.html#!problemId=1183 编辑距离,又称Levenshtein距离(也叫做Edit Distance),是指两个字串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 例如将kitten一字转成sitting: sitten (k->s) sittin (e->i) sitting (->g) 所以k

字符串相似度算法——Levenshtein Distance算法

Levenshtein Distance 算法,又叫 Edit Distance 算法,是指两个字符串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符.一般来说,编辑距离越小,两个串的相似度越大. 算法实现原理图解: a.首先是有两个字符串,这里写一个简单的 abc 和 abe b.将字符串想象成下面的结构. A 处 是一个标记,为了方便讲解,不是这个表的内容.   abc a b c abe 0 1 2 3 a 1 A处  

算法学习(十二)最大连续乘积子串、字符串编辑距离

最大连续乘积子串 题目描述:给一个浮点数序列,取最大乘积连续子串的值,例如-2.5,4,0,3,0.5,8,-1,则取出的最大乘积子串为3,0.5,8.也就是说,上述数组中,3,0.5,8这3个数的乘积3*0.5*8 = 12是最大的,而且是连续的. 分析: 注意子串和字序列的区别. 子串:是串的连续的部分. 子序列:是串中不改变顺序,但是是去掉个别元素的到新的序列. 1,连续数的乘积,最简单的就是穷举法,就是区间[i-j]之间的数的乘积,和最大值max比较,最后输出max.但是时间复杂度很大几

编辑距离和编辑距离的动态规划算法(Java代码)

编辑距离概念描述: 编辑距离,又称Levenshtein距离,是指两个字串之间,由一个转成另一个所需的最少编辑操作次数.许可的编辑操作包括将一个字符替换成另一个字符,插入一个字符,删除一个字符. 例如将kitten一字转成sitting: sitten (k→s) sittin (e→i) sitting (→g) 俄罗斯科学家Vladimir Levenshtein在1965年提出这个概念. 编辑距离的应用在信息检索.拼写纠错.机器翻译.命名实体抽取.同义词寻找等问题中有较多的应用 问题:找出

Atitti knn实现的具体四个距离算法 欧氏距离、余弦距离、汉明距离、曼哈顿距离

Atitti knn实现的具体四个距离算法  欧氏距离.余弦距离.汉明距离.曼哈顿距离 1. Knn算法实质就是相似度的关系1 1.1. 文本相似度计算在信息检索.数据挖掘.机器翻译.文档复制检测等领域有着广泛的应用1 2. 汉明距离1 2.1. 历史及应用1 3. 曼哈顿距离2 3.1. SimHash + 汉明距离3 3.2. .简单共有词4 1. Knn算法实质就是相似度的关系 1.1. 文本相似度计算在信息检索.数据挖掘.机器翻译.文档复制检测等领域有着广泛的应用 数据挖掘的过程中,只用