LeetCode：72. 编辑距离（python）

给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。

你可以对一个单词进行如下三种操作：

  1. 插入一个字符
  2. 删除一个字符
  3. 替换一个字符

示例 1:

输入: word1 = “horse”, word2 = “ros” 输出: 3 解释: horse -> rorse (将 ‘h’ 替换为 ‘r’) rorse -> rose (删除 ‘r’) rose -> ros (删除 ‘e’)

示例 2:

输入: word1 = “intention”, word2 = “execution” 输出: 5 解释: intention -> inention (删除 ‘t’) inention -> enention (将 ‘i’ 替换为 ‘e’) enention -> exention (将 ‘n’ 替换为 ‘x’) exention -> exection (将 ‘n’ 替换为 ‘c’) exection -> execution (插入 ‘u’)

LeetCode 链接

思路1：递归（超时）
1. 分析背景：通过改变 word1 使其与 word2 相同，计算需要操作的次数。
  • i、j 分别指向 word1、word2 中的某位置（初始指向字符串尾部）
  • 若 word1[i]=word2[j]，则编辑距离为 0，不需要进行操作，此时需要同时将 i、j 左移。
  • 若 word1[i]！=word2[j]，则需要进行插入、删除、替换操作使得对应字符相同：
  • 对 word1 的 i 位置后进行插入字符操作，此时将 j 左移，操作数 +1；
  • 对 word1 的 i 位置处字符进行替换操作，此时将 i 和 j 同时左移，操作数 +1；
  • 对 word1 的 i 位置处字符进行删除操作，此时将 i 左移，操作数 +1。
  • 最终取word1=word2时最小的操作数
2. 使用递归将所有情况遍历，返回满足条件的最小操作数
附代码1（Python3）：
# 递归
class Solution:
    def minDistance(self, word1, word2):
        n1, n2 = len(word1), len(word2)
        
        def dp(i, j):
            if i==-1: return j+1    # word1 遍历完，返回 word2 的长度，即需要添加的步数
            if j==-1: return i+1    # word2 遍历完，返回 word1 的长度，即需要删除的步数
            
            if word1[i] == word2[j]:       # 若字符串对应位置相等，则指针左移，不做操作
                return dp(i-1, j-1)
            else:                          # 若字符串对应位置不相等，则进行插入、删除、替换操作
                return min(
                            dp(i, j-1)+1,     # 插入操作
                            dp(i-1, j)+1,     # 删除操作
                            dp(i-1, j-1)+1    # 替换操作
                            )
        # 调用递归函数 
        return dp(n1-1, n2-1)
test = Solution()
word1_li = ["horse", "intention"]
word2_li = ["ros", "execution"]
for word1, word2 in zip(word1_li, word2_li):
    print(test.minDistance(word1, word2))
3
5
思路2：记忆递归

分析：普通的递归方案中存在大量的重叠子问题，如下示例，因此可采用携带记忆的递归方式进行剪枝。

示例：目的为 dp[i][j] --> dp[i-1][j-1] 可通过如下 3 种路线到达

  1. dp[i][j] --> dp[i-1][j-1]
  2. dp[i][j] --> dp[i-1][j] --> dp[i][j-1]
  3. dp[i][j] --> dp[i][j-1] --> dp[i-1][j]
附代码2.1（python3）:（初始位置在字符串尾部）
# 携带记忆的递归
class Solution:
    def minDistance(self, word1, word2):
        memo = dict()                   # 记忆
        def dp_memo(i, j):
            if i==-1: 
                memo[(i, j)] = j+1
                return memo[(i, j)]    
            if j==-1: 
                memo[(i, j)] = i+1
                return memo[(i, j)]    
            
            if (i, j) in memo:         # 若该状态存在记忆中，则直接返回
                return memo[(i, j)]
            
            if word1[i] == word2[j]:       
                memo[(i, j)] = dp_memo(i-1, j-1)
                return memo[(i, j)]
            else:                          
                memo[(i, j)] = min(dp_memo(i, j-1)+1, dp_memo(i-1, j)+1, dp_memo(i-1, j-1)+1)
                return memo[(i, j)] 
        # 调用携带记忆的递归函数 
        return dp_memo(len(word1)-1, len(word2)-1)
test = Solution()
word1_li = ["horse", "intention"]
word2_li = ["ros", "execution"]
for word1, word2 in zip(word1_li, word2_li):
    print(test.minDistance(word1, word2))
3
5
附代码2.2（python3）:（初始位置在字符串头部）
# 携带记忆的递归，头指针向尾指针移动
class Solution:
    def minDistance(self, word1, word2):
        memo = dict()                   # 记忆
        def dp_memo(i, j):
            if i==len(word1): 
                memo[(i, j)] = len(word2)-j
                return memo[(i, j)]    
            if j==len(word2): 
                memo[(i, j)] = len(word1)-i
                return memo[(i, j)]    
            
            if (i, j) in memo:         # 若该状态存在记忆中，则直接返回
                return memo[(i, j)]
            
            if word1[i] == word2[j]:       
                memo[(i, j)] = dp_memo(i+1, j+1)
                return memo[(i, j)]
            else:                          
                memo[(i, j)] = min(dp_memo(i, j+1)+1, dp_memo(i+1, j)+1, dp_memo(i+1, j+1)+1)
                return memo[(i, j)] 
        # 调用携带记忆的递归函数 
        return dp_memo(0, 0)
test = Solution()
word1_li = ["horse", "intention"]
word2_li = ["ros", "execution"]
for word1, word2 in zip(word1_li, word2_li):
    print(test.minDistance(word1, word2))
3
5
思路3：动态规划

分析：从以上的递归算法（初始位置在字符串尾部）中，可推断出状态转移方程如下。

dp[i][j] = dp[i-1][j-1] if word1[i] = word2[j]

dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1])+1 if word1[i] != word2[j]

  • 动态转移方向为从上往下，从左往右
  • 初始值，比较 word1[0] 与 word2[0]，此时需要知道 dp[-1][-1] 的情况，添加第 0 行和第 0 列，设置大小为 (n1+1)*(n2+1) 的 dp 数组方便计算，n1 为 word1 的长度，n2 为 word2的长度。
  • 设置 dp[0][0]=0 表示 word1 和 word2 皆为空，操作数为 0；
  • 设置 dp[1][0]~dp[n1][0] 为 0~n1，表示 word2 为空时，word1 需要删除的操作数；
  • 设置 dp[0][1]~dp[0][n2] 为 0~n2，表示 word1 为空时，word1 需要插入的操作数。
  • 返回值，dp[n1][n2] 表示 word1 与 word2已遍历结束的最小操作数，即 word1[n1-1] 与 word2[n2-1]处。
附代码3（Python3）：
# 动态规划
class Solution:
    def minDistance(self, word1, word2):
        n1, n2 = len(word1), len(word2)
        # 初始化 dp 数组
        dp = [[0]*(n2+1) for _ in range(n1+1)]
        for i in range(n1+1):            # 第 0 列
            dp[i][0] = i
        for j in range(n2+1):            # 第 0 行
            dp[0][j] = j
        # 更新 dp 数组
        for i in range(1, n1+1):
            for j in range(1, n2+1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1]) + 1
        return dp[n1][n2]
test = Solution()
word1_li = ["horse", "intention"]
word2_li = ["ros", "execution"]
for word1, word2 in zip(word1_li, word2_li):
    print(test.minDistance(word1, word2))
3
5
参考：

LeetCode 题解