题目
给你两个单词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(mn)，空间复杂度同样为O(mn)，这是因为我们需要一个二维数组来存储所有的子问题解。动态规划法能够有效地解决编辑距离问题，避免了递归法中的重复计算，是解决此类问题的标准方法之一。
