编辑距离

编辑距离理论分析与实现

编辑距离定义

​ 两个字符串之间，由一个字符串经过一系列操作变成另一个字符串所需的操作步数。支持的操作为：

• 插入一个字符

• 删除一个字符

• 替换一个字符

  例如 dog 变为 cat, 所需要的操作为：

  dog -> cog (d 替换为 c)

  cog -> cag (o 替换为 a)

  cag -> cat (g 替换为 t)

  如果一次替换操作代表的距离为 1 的话， 那么dog 与 cat 的编辑距离就是 3。

编辑距离的应用场景

​ 编辑距离在nlp自然语言处理中有一定的应用，可以用来计算两个字符串之间的相似度，可以作为一些算法中的距离度量函数，可以用于聚类、分类。在一些字符串语义较窄的实际业务场景中，编辑距离的效果可能会比一些语言模型（如word2vec）的效果还要好，因为在语义较窄的场景中，同一语义下的多个词之间不同字的个数和概率都较小，这也是编辑距离在这种场景之下效果好的主要原因。

编辑距离的求解思路

​ 求字符串 A （长度为m）与 字符串 B (长度为n) 之间的编辑距离，等价于求 字符串A的前m个字符转换为字符串B的前n个字符所需要的操作步数。

​ 上面的等价问题，依赖于之前的一些计算结果：

• 字符串A的前m-1个字符转换为字符串B的前n-1个字符所需要的操作步数
• 字符串A的前m个字符转换为字符串B的前n-1个字符所需要的操作步数
• 字符串A的前m-1个字符转换为字符串B的前n个字符所需要的操作步数

​ 我们可以使用动态规划来解决这个问题，动态规划问题可以分解为三个问题，这三个问题分别为：

• 使用数组存储计算的中间值，明确数组中元素的含义
• 数组元素间的依赖关系
• 初始值

​ 在求解编辑距离的问题中，我们使用一个二维矩阵来存储操作步数，比如dp[m] [n] 表示字符串A的前m个字符转换为字符串B的前n个字符所需要的操作步数。对于dp[m] [n]而言，依赖情况可以分为以下几种：

• A 的第m个字符与 B的第n个字符相等，此时
  $$dp[m][n]=dp[m-1][n-1]$$

• A 的 第m个字符与 B的第n个字符不相等，此时又可以分为以下几种情况

  • 如果 m==n, 那么
    $$dp[m][n]=dp[m-1][n-1]+1$$

  • 如果 m < n, 那么
    $$dp[m][n]=dp[m][n-1]+1$$

  • 如果 m > n, 那么
    $$dp[m][n]=dp[m-1][n]+1$$

​ 通过以上关系式我们发现，m、n的最小取值都为1， 如果取到0的话，数组的下标会为负值。在m、n分别取1的情况下，我们需要知道的边界值为dp[0] [i]和dp[j] [0]，其中dp[0] [i]表示从长度为0的字符串变为长度为i的另一字符串所需的操作步数， dp[j] [0]表示从长度为j的字符串变为长度为0的另一字符串所需的操作步数。

​ 经过以上分析，我们就完成了解动态规划问题所需的三个步骤。

编辑距离的代码实现

​ Python 版本：

def levenshteinDistance(str1, str2):
    m,n = len(str1),len(str2)
    if m == 0:
        return n
    if n == 0:
        return m
    # 申请内存
    dp = [[0 for i in range(0, n+1)] for j in range(0, m+1)]
    # 初值
    for row in range(0, m+1):
        dp[row][0] = row
    for col in range(0, n+1):
        dp[0][col] = col
    # 依赖关系
    for i in range(1, m+1):
        for j in range(1, n+1):
            if str1[i-1] == str2[j-1]:
                dp[i][j]  = dp[i-1][j-1]
            else:
                if i == j:
                    dp[i][j]  = dp[i-1][j-1]  + 2 # 替换, 替换一次的距离可以自定义，这里定义为2
                elif i < j:
                    dp[i][j]  = dp[i][j-1]  + 1 # 插入
                elif i > j:
                    dp[i][j]  = dp[i-1][j]  + 1 # 删除
    return dp[m][n]

编辑距离存在的不足

​ 编辑距离没有考虑语义上的相似性，而只是考虑了字符的相似性，所以捕捉不到深层次的语义关系。比如对于“身份证”、“身份证明”、“二代证”，我们分别计算编辑距离：

s1 = '身份证'
s2 = '身份证明'
s3 = '二代证'
print('{} 与 {} 的 编辑距离为 {}'.format(s1, s2, levenshteinDistance(s1, s2)))
print('{} 与 {} 的 编辑距离为 {}'.format(s1, s3, levenshteinDistance(s1, s3)))

结果为：

身份证 与 身份证明 的 编辑距离为 1
身份证 与 二代证 的 编辑距离为 4

​ 从结果上看， 身份证与身份证明 比 身份证与二代证的编辑距离近。但是在实际语义上身份证与二代证距离近，所以编辑距离的缺点就在于不能挖掘字符串背后的语义。