题目
给你两个单词word1和word2,请返回将word1转换成word2所使用的最少操作数。你可以对一个单词进行如下三种操作:插入一个字符、删除一个字符、替换一个字符。
备注:word1和word2均由小写英文字母组成。
示例 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')
递归法
字符串的编辑距离,也叫莱文斯坦距离,是针对二个字符串的差异程度的量化量测,量测方式是看至少需要多少次的处理(插入、删除或替换)才能将一个字符串变成另一个字符串。
递归法解决莱文斯坦距离的基本思想是:将问题分解为更小的子问题,直到子问题可以直接求解为止。在本题中,我们可以通过递归的方式比较两个字符串的最后一个字符,并基于这个比较结果来决定下一步的操作。使用递归法求解本题的主要步骤如下。
1、如果word1或word2的长度为0,则编辑距离就是另一个字符串的长度。
2、如果word1的最后一个字符与word2的最后一个字符相同,则递归计算word1[:-1]和word2[:-1]的编辑距离。
3、如果 word1的最后一个字符与word2的最后一个字符不同,则递归计算以下三种情况下的编辑距离,并取其中的最小值。
(1)删除word1的最后一个字符,递归计算word1[:-1]和word2的编辑距离。
(2)插入一个字符到word1,相当于删除word2的最后一个字符,递归计算word1和word2[:-1]的编辑距离。
(3)替换word1的最后一个字符为word2的最后一个字符,递归计算word1[:-1]和word2[:-1]的编辑距离。
根据上面的算法步骤,我们可以得出下面的示例代码。
def edit_distance_of_strings_by_recursion(word1, word2):
if not word1:
return len(word2)
if not word2:
return len(word1)
# 如果最后一个字符相同,则不需要操作
if word1[-1] == word2[-1]:
return edit_distance_of_strings_by_recursion(word1[:-1], word2[:-1])
# 如果最后一个字符不同,则考虑以下三种操作
# 插入
add = 1 + edit_distance_of_strings_by_recursion(word1, word2[:-1])
# 删除
remove = 1 + edit_distance_of_strings_by_recursion(word1[:-1], word2)
# 替换
replace = 1 + edit_distance_of_strings_by_recursion(word1[:-1], word2[:-1])
return min(add, remove, replace)
word1 = "horse"
word2 = "ros"
print(edit_distance_of_strings_by_recursion(word1, word2))
word1 = "intention"
word2 = "execution"
print(edit_distance_of_strings_by_recursion(word1, word2))
动态规划法
动态规划法通过构建一个二维数组来存储子问题的解,从而避免了重复计算。我们定义dp[i][j]为将word1的前i个字符转换为word2的前j个字符所需的最小操作数。状态转移方程取决于当前字符是否相同,具体如下。
1、如果word1[i-1] == word2[j-1],则不需要进行任何操作,此时dp[i][j] = dp[i-1][j-1]。
2、如果word1[i-1] != word2[j-1],则需要考虑三种操作中的一种。
(1)删除word1的第i个字符,即:dp[i][j] = dp[i-1][j] + 1。
(2)插入一个字符到word1使得它与word2[j-1]相同,即:dp[i][j] = dp[i][j-1] + 1。
(3)替换word1[i-1]为word2[j-1],即:dp[i][j] = dp[i-1][j-1] + 1。
使用动态规划法求解本题的主要步骤如下。
1、初始化一个(m+1) x (n+1)的二维数组dp,其中m和n分别是word1和word2的长度。
2、设置边界条件:dp[0][j] = j 和 dp[i][0] = i。
3、遍历数组dp,根据当前字符是否相同来填充dp[i][j]的值。
4、最终的答案位于dp[m][n]。
根据上面的算法步骤,我们可以得出下面的示例代码。
def edit_distance_of_strings_by_dp(word1, word2):
m, n = len(word1), len(word2)
# 初始化dp数组
dp = [[0] * (n + 1) for _ in range(m + 1)]
# 设置边界条件
for i in range(m + 1):
dp[i][0] = i
for j in range(n + 1):
dp[0][j] = j
# 填充dp数组
for i in range(1, m + 1):
for j in range(1, n + 1):
if word1[i - 1] == word2[j - 1]:
dp[i][j] = dp[i - 1][j - 1]
else:
dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
return dp[m][n]
word1 = "horse"
word2 = "ros"
print(edit_distance_of_strings_by_dp(word1, word2))
word1 = "intention"
word2 = "execution"
print(edit_distance_of_strings_by_dp(word1, word2))
总结
本题使用的递归法没有使用任何缓存机制,因此可能会重复计算很多相同的子问题。其时间复杂度非常高,接近于O(3^(m+n)),其中m和n分别是word1和word2的长度。
动态规划方法的时间复杂度为O(m*n),空间复杂度同样为O(m*n),这是因为我们需要一个二维数组来存储所有的子问题解。动态规划法能够有效地解决编辑距离问题,避免了递归法中的重复计算,是解决此类问题的标准方法之一。
💡 需要《Python面试宝典》完整源码的大佬们,可订阅专栏后,搜索微信公众号“希望睿智”私信获取。