最小编辑距离 -- 解析及python实现_python编辑距离法 原理

一、题目要求

二、实验原理

三、实验代码

       1. 方法一：递归

       2. 方法二：动态规划

四、结果

---

一、题目要求

尝试用python写一段最小编辑距离计算的代码

两个字符串之间，有一个转变成另一个所需要的操作数量

支持三种操作输入 Insertion   Deletion  Substitution

二、实验原理

    编辑距离（Edit Distance），又称Levenshtein距离，是指两个字串之间，由一个转成另一个所需的最少编辑操作次数。许可的编辑操作包括将一个字符替换成另一个字符，插入一个字符，删除一个字符。一般来说，编辑距离越小，两个串的相似度越大

    给定两个字符串，求由一个转成另一个所需要的最少编辑操作次数。

    在5X5的列表中，s[i][j]表示：字符串A前i个字符与字符串B前j个字符的最短编辑距离。求最小编辑距离就是把这个列表填写完，s[4][4]的值即为所求的最小编辑距离。

思路：

1. 当Ai和Bj的末尾字符A[i]==B[j]时，对末尾字符不需要进行编辑，  diff = 0，step[i][j] = step[i-1][j-1]

2. 当Ai和Bj的末尾字符A[i]!=B[j]时，需要对其中之一的末尾进行编辑， diff = 1

 （1）先A[i-1]->B[j]再A[i]->B[j]       step[i][j] = step[i-1][j]+diff

 （2）先A[i]->B[j-1]再A[i]->B[j]       step[i][j] = step[i][j-1]+diff

 （3）先A[i-1]->B[j-1]再A[i]->B[j]      step[i][j] = step[i-i][j-1]+diff

取三种操作的最小值，就是Ai->Bj的最小编辑距离      step[i][j] = min(step[i-1][j], step[i][j-1], step[i-i][j-1])+diff

3.特殊情况，
if(A == null)  step[0][j] = j
if(B == null)  step[i][0] = i

4.最后step[len(A)][len(B)]即为A->B的最小标记距离。

填写表格：

1. 填写s[1]过程：
A[1]==B[1]，s[1][1]=min(s[1][0],s[0][0],s[0][1])+0=0
A[1]!=B[2]，s[1][2]=min(s[1][1],s[0][1],s[0][2])+1=1
A[1]!=B[3]，s[1][3]=min(s[1][2],s[0][2],s[0][3])+1=2
A[1]!=B[4]，s[1][4]=min(s[1][3],s[0][3],s[0][4])+1=3

 

2. 填写s[2]过程：
A[2]!=B[1]，s[2][1]=min(s[2][0],s[1][0],s[1][1])+1=1
A[2]!=B[2]，s[2][2]=min(s[2][1],s[1][1],s[1][2])+1=1
A[2]==B[3]，s[2][3]=min(s[2][2],s[1][2],s[1][3])+0=1
A[2]!=B[4]，s[2][4]=min(s[2][3],s[1][3],s[1][4])+1=2

 

3. 填写s[3]过程：
A[3]!=B[1]，s[3][1]=min(s[3][0],s[2][0],s[2][1])+1=2
A[3]!=B[2]，s[3][2]=min(s[3][1],s[2][1],s[2][2])+1=2
A[3]!=B[3]，s[3][3]=min(s[3][2],s[2][2],s[2][3])+1=2
A[3]==B[4]，s[3][4]=min(s[3][3],s[2][3],s[3][4])+0=1

 

4. 填写s[4]过程：
A[4]!=B[1]，s[4][1]=min(s[4][0],s[3][0],s[3][1])+1=3
A[4]!=B[2]，s[4][2]=min(s[4][1],s[3][1],s[3][2])+1=3
A[4]!=B[3]，s[4][3]=min(s[4][2],s[3][2],s[3][3])+1=3
A[4]!=B[4]，s[4][4]=min(s[4][3],s[3][3],s[3][4])+1=2

 

所以A—>B编辑距离为2次，操作为：acef在字符ac之间插入字符b，删除字符f

三、实验代码

1. 方法一：递归

A = input("输入字符串1：")
B = input("输入字符串2：")
def recursive_edit_distance(str_a, str_b):
    if len(str_a) == 0:
        return len(str_b)
    elif len(str_b) == 0:
        return len(str_a)
    elif str_a[len(str_a)-1] == str_b[len(str_b)-1]:
        return recursive_edit_distance(str_a[0:-1], str_b[0:-1])
    else:
        return min([
            recursive_edit_distance(str_a[:-1], str_b),
            recursive_edit_distance(str_a, str_b[:-1]),
            recursive_edit_distance(str_a[:-1], str_b[:-1])
        ]) + 1
print(recursive_edit_distance(A, B))

2. 方法二：动态规划

import nltk
A = input("输入字符串1：")
B = input("输入字符串2：")
def minDistance(w1, w2):
   m, n = len(w1),len(w2)
   if(m == 0):
      return m
   if(n == 0):
      return n
   step = [[0]*(n+1)for _ in range(m + 1)]
   for i in range(1, m+1):step[i][0]=i
   for j in range(1, n+1):step[0][j]=j
   for i in range(1, m+1):
      for j in range(1, n+1):
         if w1[i-1] == w2[j-1] :
            diff=0
         else:diff=1
         step[i][j] = min(step[i-1][j-1],min(step[i-1][j],step[i][j-1]))+diff
   return step[m][n]
print(minDistance(A,B))
打印出完整变换：
A = input("输入字符串1：")
B = input("输入字符串2：")
def edit_distance_Omn(str_a, str_b):
    if str_a == str_b:
        return 0
    if len(str_a) == 0:
        return len(str_b)
    if len(str_b) == 0:
        return len(str_a)
    dp = [[0 for _ in range(len(str_a) + 1)] for _ in range(len(str_b) + 1)]
    for i in range(len(str_b) + 1):
        dp[i][0] = i
    for j in range(len(str_a) + 1):
        dp[0][j] = j
    for i in range(1, len(str_b) + 1):
        for j in range(1, len(str_a) + 1):
            dp[i][j] = dp[i-1][j-1]
            if str_a[j-1] != str_b[i-1]:
                dp[i][j] = min([dp[i-1][j-1], dp[i-1][j], dp[i][j-1]]) + 1
  #打印完整路径矩阵（这一步非必要）
    '''for i in range(len(str_b) + 1):
        for j in range(len(str_a) + 1):
            print(dp[i][j])
        # print()'''
  # 准备倒着查询编辑路径，从右下角开始
    i , j = len(str_b), len(str_a)
    op_list = []  # 记录编辑操作
    while i > 0 and j > 0:
        if dp[i][j] == dp[i-1][j-1]:
            op_list.append("keep [ {} ]".format(str_b[i-1]))
            i, j = i-1, j-1
            continue
        if dp[i][j] == dp[i-1][j]  + 1:
            op_list.append("remove [ {} ]".format(str_b[i-1]))
            i, j = i-1, j
            continue
        if dp[i][j] == dp[i-1][j-1] + 1:
            op_list.append("change [ {} ] to [ {} ]".format(str_b[i-1], str_a[j-1]))
            i, j = i-1, j-1
            continue
        if dp[i][j] == dp[i][j-1] + 1:
            op_list.append("insert [ {} ]".format(str_a[j-1]))
            i, j = i, j-1
    for i in range(len(op_list)):
        print(op_list[len(op_list)-i-1])
    return dp[len(str_b)][len(str_a)]
print(edit_distance_Omn(A, B))

四、结果

参考链接：

https://www.cnblogs.com/AsuraDong/p/6957890.html

https://blog.csdn.net/qq_33085753/article/details/86595452

https://www.cnblogs.com/CheeseZH/p/8821282.html