动态规划之最小编辑距离

概述

最小编辑距离(Minimum Edit Distance)本身是的一个NLP中的一个概念,最小编辑距离旨在定义两个字符串之间的相似度(word similarity)。定义相似度可以用于拼写纠错,计算生物学上的序列比对,机器翻译,信息提取,语音识别等。

编辑距离

两个字符串之间有多相似?

在搜索引擎中,我们总会有偶尔拼错单词的情况,但我们会发现,即便我们拼错了,搜索引擎也能正确地显示出我们想要的结果,而且还会温馨地给出拼写错误的提示。

如果我们在Google中检索”Gooogle”,我们会看到如下结果。

Showing results for google
Search instead for gooogle

Google知道我们输错了,但是它是怎么知道我们输错的呢?

同样地,在生物学中,我们想知道两段DNA或者RNA的有多相似,也会遇到类似的问题。

Seq1: AGGCTATCACCTGACCTCCAGGCCGATGCCC

Seq2: TAGCTATCACGACCGCGGTCGATTTGCCCGAC

对比结果:

Seq1: -AGGCTATCACCTGACCTCCAGGCCGA–TGCCC—

Seq2: TAG-CTATCAC–GACCGC–GGTCGATTTGCCCGAC

同样类似的场景还有很多,我们可以从中抽取出一个共通的问题,即从一个字符串转变为另一个字符串,需要经过怎样的编辑操作。

编辑距离和最小编辑距离

为了解决该问题,我们引入了编辑距离的概念,所谓的编辑距离,就是从串A转换到串B所需的编辑操作次数。

这里的编辑操作包括:

  • 插入
  • 删除
  • 替换

最小编辑距离(Minimum Edit Distance)就很容易理解了,就是从串A转换到串B所需的最少编辑操作次数(对应的代价)之和

现在我们来考虑intentionexecution两个单词之间的编辑距离。

动态规划之最小编辑距离_第1张图片

从上表可以看出,从intentionexecution需要1次删除,3次替换,和1次插入。

如果我们把三种操作的代价都记为1,则其编辑距离为5

除此之外还有一种计算方法将替换的记为2(即一次删除和一次插入),这种距离也被称为列文斯坦(Levenshtein)距离,此时的总距离为8

动态规划求解MED

算法思想及伪码描述

求解MED最常用的方法采用了动态规规划的思想,计算过程中通过构建一张编辑距离表的方式,将串X到串Y的每一个编辑状态计算出来,每一步计算状态依赖于之前的计算状态。

# 伪码描述
D(i, 0) = i;
D(0, j) = j;
For each i = 1...M
	For each j = 1...N
		d1 = D(i - 1, j) + 1
		d2 = D(i, j - 1) + 1
		d3 = D(i - 1, j - 1) + X(i) === Y (j) ? 0 : 2
		D(i, j) = min(d1, d2, d3)

其中D(n, m)是距离,X(i)表示串X第i个位置的字符,Y(j)表示串Y第j个位置的字符。

编辑距离表

通过上述思想,我们可以构建一张编辑距离表。

首先初始化的时候其距离为,表的状态为:

N 9
O 8
I 7
T 6
N 5
E 4
T 3
N 2
I 1
# 0 1 2 3 4 5 6 7 8 9
# E X E C U T I O N

怎么理解这个表呢?

我们从倒数第二行开始,其第一列为#,表示一个空字符串,##对应的值为0,表示从一个空字符串到一个空字符串的MED为0

#E对应的值为1,表示从空字符串到E的MED为1#X对应的值为2,表示从空字符串到EX的MED为2,以此类推。

反过来,从第二列由下往上推也是同理。

现在我们完成了编辑距离表的初始化,接下来要完成整个表的填充。

实际上对于第D(n, m)的计算在伪码的描述中已经很明确了,就是求三个数值的最小值,第一个数值是表中当前位置的左边的数值 + 1,第二个数值是当前位置下面的数值 + 1,第三个数值相对复杂一点,如果当前位置对应的两个字符一样,则第三个数值就是左下角的数值,表示不需要做任何编辑,否则的话左下角的数字 + 2,表示是一次替换操作(这里认为一次替换操作的代价是2)。

现在我们来求倒数第三行第三列的数值,从上表可以看出,d1 = 1 + 1d2 = 1 + 1d3 = 0 + 2,三个值的最小值为2,所以D(0, 0) = 2

N 9
O 8
I 7
T 6
N 5
E 4
T 3
N 2
I 1 2
# 0 1 2 3 4 5 6 7 8 9
# E X E C U T I O N

同样的道理可以求出,D(1, 2) = min(2 + 1, 2 + 1, 1 + 2),即3

一直这样计算我们可以得出:

N 9
O 8
I 7
T 6
N 5
E 4
T 3
N 2
I 1 2 3 4 5 6 7 6
# 0 1 2 3 4 5 6 7 8 9
# E X E C U T I O N

接下来我们计算D(0, 6),可以发现X(0)Y(6)是相同的,都是'I',所以这里的值应该是min(7 + 1, 7 + 1, 6 + 0),即6

一次类推,我们可以将整个编辑距离表计算出来。

N 9 8 9 10 11 12 11 10 9 8
O 8 7 8 9 10 11 10 9 8 9
I 7 6 7 8 9 10 9 8 9 10
T 6 5 6 7 8 9 8 9 10 11
N 5 4 5 6 7 8 9 10 11 10
E 4 3 4 5 6 7 8 9 10 9
T 3 4 5 6 7 8 7 8 9 8
N 2 3 4 5 6 7 8 7 8 7
I 1 2 3 4 5 6 7 6 7 8
# 0 1 2 3 4 5 6 7 8 9
# E X E C U T I O N

最终可以算出表中右上角的数值是8,也就是说从INTENTIONEXECUTION的最小编辑距离为8

带追溯过程的最小编辑编辑

求得最小编辑距离的值是不够的,我们还可以将整个过程回溯的过程记录下来,即我们是怎么计算出8这个值的。

N 9↓ 8↓ 9←↙↓ 10←↙↓ 11←↙↓ 12←↙↓ 11↓ 10↓ 9↓ 8
O 8↓ 7↓ 8←↙↓ 9←↙↓ 10←↙↓ 11←↙↓ 10↓ 9↓ 8 9←
I 7↓ 6↓ 7←↙↓ 8←↙↓ 9←↙↓ 10←↙↓ 9↓ 8 9← 10←
T 6↓ 5↓ 6←↙↓ 7←↙↓ 8←↙↓ 9←↙↓ 8 9← 10← 11←↓
N 5↓ 4↓ 5←↙↓ 6←↙↓ 7←↙↓ 8←↙↓ 9←↙↓ 10←↙↓ 11←↙↓ 10↙↓
E 4↓ 3↙ 4↙ 5 6 7← 8←↓ 9←↙↓ 10←↙↓ 9↓
T 3↓ 4←↙↓ 5←↙↓ 6←↙↓ 7←↙↓ 8←↙↓ 7↙ 8←↓ 9←↙↓ 8↓
N 2↓ 3←↙↓ 4←↙↓ 5←↙↓ 6←↙↓ 7←↙↓ 8←↙↓ 7↙↓ 8←↙↓ 7↙
I 1 2←↙↓ 3←↙↓ 4←↙↓ 5←↙↓ 6←↙↓ 7←↙↓ 6↙ 7← 8←
# 0 1← 2← 3← 4← 5← 6← 7← 8← 9←
# E X E C U T I O N

这样我们可以记录一整个编辑过程。

从上图的右上角开始,我们可以划出一条完整的追溯路径。

下表是从右向左填写的。

X I N T E - N T I O N
Y - E X E C U T I O N
Action Delete Substitute Substitute Insert Substitute

是不是和本文一开始的那张图一模一样呢?

1次删除,3次替换,和1次插入,编辑距离正好是8

C++实现

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n = word1.size(),m = word2.size();
        vector> dp(n+1, vector(m+1));
        for(int i = 0;i <= n; ++i) dp[i][0] =  i;
        for(int j = 0;j <= m; ++j) dp[0][j] =  j;
        for(int i = 1;i<=n;++i){
            for(int j = 1;j<=m;++j){
                if(word1[i-1] == word2[j-1])
                    dp[i][j] = dp[i-1][j-1];
                else
                    dp[i][j] = 1 +min(dp[i-1][j-1],min(dp[i][j-1],dp[i-1][j]));
            }
        }
        return dp[n][m];
    }
};

总结

最小编辑距离还有一种加权最小编辑距离的形式,用于处理某些改动频率不一的情况,本文不再赘述,感兴趣的同学可以查看参考1。

参考

  1. Minimum Edit Distance - Dan Jurafsky - Stanford
  2. 深度剖析:如何实现一个 Virtual DOM 算法 - livoras

你可能感兴趣的:(动态规划之最小编辑距离)