编辑距离

定义 编辑距离（Edit Distance）又称Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数，如果它们的距离越大，说明它们越是不同。
许可的编辑操作只包括三种：
（1）将一个字符替换成另一个字符， 例如， xyz -> xym
（2）插入一个字符，例如，xy -> xyz
（3）删除一个字符，例如，xyz -> xy

1. 分治思想

用分治的思想解决比较简单，将复杂的问题分解成相似的子问题

假设字符串 a, 共 m 位，从 a[0] 到 a[m-1]；字符串 b, 共 n 位，从 b[0] 到 b[n-1]， d[i][j] 表示字符串 a[0]->a[i+1] 转换为 b[0]->b[j+1] 的编辑距离。

那么有如下递归规律（a[i] 和 b[j] 分别是字符串 a 和 b 的最后一位）：

当 a[i] 等于 b[j] 时，d[i][j] = d[i-1][j-1], 比如 xyz -> xnz 的编辑距离等于 xy -> xn 的编辑距离当 a[i] 不等于 b[j] 时，d[i][j] 等于如下 3 项的最小值，分别对应三种操作：    d[i-1][j] + 1（删除操作：1. 将a[0]-->a[i]变成a[0]-->a[i-1]，2.将a[0]-->a[i-1]变成b[0]-->b[j]）    d[i][j-1] + 1（插入操作：1. 将a[0]-->a[i]变成b[0]-->b[j-1]，2.将b[0]-->b[j-1]变成b[0]-->b[j])，     d[i-1][j-1] + 1（替换操作：将 a[i] 替换为 b[j]）

递归边界：

a[i][0] = i, b 字符串为空，表示将 a[1]-a[i] 全部删除，所以编辑距离为 ia[0][j] = j, a 字符串为空，表示 a 插入 b[1]-b[j]，所以编辑距离为 j

python代码如下:

def editDistance(str_a, str_b):    # 查询递归边界    if len(str_a) == 0:        return len(str_b)    if len(str_b) == 0:        return len(str_a)    # 递归    if str_a[-1] == str_b[-1]:        return editDistance(str_a[0:-1],str_b[0:-1])    if str_a[-1] != str_b[-1]:        return min(editDistance(str_a[0:-1],str_b)+1,editDistance(str_a,str_b[0:-1])+1,editDistance(str_a[0:-1],str_b[0:-1])+1)

str_a = u'床前明月光,疑是地上霜,举头望明月,低头思故乡'str_b = u'床前明月光,地上有张床,举头望明月,地头有蚊香'% time print editDistance(str_a,str_b)

9CPU times: user 8 ms, sys: 0 ns, total: 8 msWall time: 27.4 ms

2. 动态规划

观察分治思想的方法，得出，要求解d[i][j]，只需要得到d[i-1][j-1]，d[i][j-1]，d[i-1][j]即可。那我们可以将问题从前往后算。我们可以先算出d[0][0]到d[0][j]以及d[0][0]到d[i][0]，然后，将矩阵d从前到后，从上往下依次计算出来，最后，d[m-1][n-1]即是我们需要的结果。时间复杂度o(m×n)。

import numpy as npdef editDistance(str_a, str_b):    # 初始矩阵    matrix_row_lengh = len(str_a)    matrix_column_lengh = len(str_b)    matrix = np.zeros([matrix_row_lengh,matrix_column_lengh])    matrix[0,:] = range(matrix_column_lengh)    matrix[:,0] = range(matrix_row_lengh)    for i in np.arange(1, matrix_row_lengh):        for j in np.arange(1,matrix_column_lengh):            if str_a[i] == str_b[j]:                matrix[i,j] = matrix[i-1,j-1]            else:                matrix[i,j] = min(matrix[i-1,j-1] + 1, matrix[i-1,j] + 1, matrix[i,j-1] + 1)    return matrix[matrix_row_lengh-1,matrix_column_lengh-1]

str_a = u'床前明月光,疑是地上霜,举头望明月,低头思故乡'str_b = u'床前明月光,地上有张床,举头望明月,地头有蚊香'% time print editDistance(str_a,str_b)

9.0CPU times: user 8 ms, sys: 0 ns, total: 8 msWall time: 5.71 ms

观察cpu的运行时间，动态规划的时间明显比分之思想的时间快。

3. 动态规划优化

观察普通的动态规划，其实要求解d[m-1][n-1]，我们在循环过程中，只用到了三个值，d[i-1][j-1]，d[i][j-1]，d[i-1][j]，即，每次循环，我们只需要矩阵d的上一行信息就可以了。这样，我们将空间复杂度从o(m×n)缩减到了o(n)。

import numpy as npdef editDistance(str_a, str_b):    # 初始化    array_len = len(str_b)    old_array = list(range(array_len))    for i in np.arange(1,len(str_a)):        new_array = list(range(array_len))        new_array[0] = i        for j in np.arange(1,len(str_b)):            if str_a[i] == str_b[j]:                new_array[j] = old_array[j-1]            else:                new_array[j] = min(old_array[j-1] + 1, old_array[j] + 1, new_array[j-1] + 1)        old_array = new_array    return old_array[array_len-1] 

str_a = u'床前明月光,疑是地上霜,举头望明月,低头思故乡'str_b = u'床前明月光,地上有张床,举头望明月,地头有蚊香'% time print editDistance(str_a,str_b)

9CPU times: user 4 ms, sys: 0 ns, total: 4 msWall time: 3.44 ms

4. python中涉及到的相关模块

from fuzzywuzzy import fuzz
print fuzz.ratio(str_a,str_b)