编辑距离

定义 编辑距离（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] 全部删除，所以编辑距离为 i
a[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)

9
CPU times: user 8 ms, sys: 0 ns, total: 8 ms
Wall 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\times n)$。

import numpy as np

def 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.0
CPU times: user 8 ms, sys: 0 ns, total: 8 ms
Wall 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\times n)$缩减到了$o(n)$。

import numpy as np

def 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)

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

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

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