Python面试宝典第42题：字符串的编辑距离

题目

        给你两个单词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面试宝典》完整源码的大佬们，可订阅专栏后，搜索微信公众号“希望睿智”私信获取。