【leetcode】72. 编辑距离

最新推荐文章于 2025-01-12 19:45:41 发布

原创最新推荐文章于 2025-01-12 19:45:41 发布 · 496 阅读

0 ·

CC 4.0 BY-SA版权

leetcode解题记录专栏收录该内容

148 篇文章

订阅专栏

博客围绕编辑距离问题展开，给定两个单词，可进行插入、删除、替换操作，计算将一个单词转换成另一个的最少操作数。通过分析不同子问题的变换步骤，得出递推公式，利用动态规划思想，每一步结果基于上一步计算，还提及边界情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

72. 编辑距离

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

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

插入一个字符
删除一个字符
替换一个字符

示例 1:

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

思路：

问题1：如果 word1[0..i-1] 到 word2[0..j-1] 的变换需要消耗 k 步，那 word1[0..i] 到 word2[0..j] 的变换需要几步呢？

答：先使用 k 步，把 word1[0..i-1] 变换到 word2[0..j-1]，消耗 k 步。再把 word1[i] 改成 word2[j]，就行了。如果 word1[i] == word2[j]，什么也不用做，一共消耗 k 步，否则需要修改，一共消耗 k + 1 步。

问题2：如果 word1[0..i-1] 到 word2[0..j] 的变换需要消耗 k 步，那 word1[0..i] 到 word2[0..j] 的变换需要消耗几步呢？

答：先经过 k 步，把 word1[0..i-1] 变换到 word2[0..j]，消耗掉 k 步，再把 word1[i] 删除，这样，word1[0..i] 就完全变成了 word2[0..j] 了。一共 k + 1 步。

问题3：如果 word1[0..i] 到 word2[0..j-1] 的变换需要消耗 k 步，那 word1[0..i] 到 word2[0..j] 的变换需要消耗几步呢？

答：先经过 k 步，把 word1[0..i] 变换成 word2[0..j-1]，消耗掉 k 步，接下来，再插入一个字符 word2[j], word1[0..i] 就完全变成了 word2[0..j] 了。

从上面三个问题来看，word1[0..i] 变换成 word2[0..j] 主要有三种手段，用哪个消耗少，就用哪个。

    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        # dp[i][j] 代表最小操作数（步骤），从 word1[0..i-1]转化为 word2[0..j-1].
        # D[i][j] 表示 word1 的前 i 个字母和 word2 的前 j 个字母之间的编辑距离。
        dp = [[0] * (m + 1) for _ in range(n + 1)]

        # for _ in range(m + 1): dp[0][_] = _
        # for _ in range(n + 1): dp[_][0] = _
        # word2动，则是插入，word1从无到有
        for a in range(m+1):dp[0][a]=a
        # word1动，则是删除，word1从有到无
        for b in range(n+1):dp[b][0]=b

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if word1[i - 1] == word2[j - 1]:
                    dp[j][i] = dp[j - 1][i - 1]
                else:
# dp[j - 1][i] word1插入
# dp[j][i - 1] word1删除
                    dp[j][i] = 1 + min(dp[j - 1][i], dp[j][i - 1], dp[j - 1][i - 1])
        return dp[n][m]

#### @2
        '''
        动态规划 
        step1: 状态  
        首先只定义一维 DP[i] 不能有效简化问题的处理
        使用 二维 DP[i][j]，表示 word1 的 第i 个字母 与 word2 的 第 j 个字母 相同 需要的操作步骤数
        将对 word1 处理 转化为 对 word1 和 word2 均处理
        word1 插入一个字符   DP[i-1][j] + 1 ->  DP[i][j]
        word1 删除一个字符 = word2 插入一个字符  DP[i][j-1] + 1 -> DP[i][j]
        word1 替换一个字符 = word1 word2 都替换一个字符 DP[i-1][j-1] + 1 -> DP[i][j]
        step2: 动态方程
        DP[i][j]  A、 word1 的 i 个字母 与 word2 的 第 j 个字母 相同
                     DP[i][j] =  DP[i-1][j-1]  #不操作
                  B、不相同,需要进行 插入 删除 或者 替换操作
                     DP[i][j]  =  min(DP[i-1][j] + 1,DP[i][j-1] + 1,DP[i-1][j-1]+1)
        
        '''
        DP = [[0 for _ in range(len2+1)] for _ in range(len1+1)]
        # 初始
        for i in range(len1+1):
            DP[i][0] = i
        for j in range(len2+1):
            DP[0][j] = j
        for i in range(1,len1+1):
            for j in range(1,len2+1):
                if word1[i - 1] == word2[j - 1]:
                    DP[i][j] =  DP[i-1][j-1]
                else:
                    DP[i][j]  =  min(DP[i-1][j] + 1,DP[i][j-1] + 1,DP[i-1][j-1]+1)
        return DP[len1][len2]

如果我想知道了 word2 的第x字母在 word1 的第y个位置的最小修改数量
我们只要遍历这三种情况就可以等到结论了,
1. 修改他,dp[x-1][y-1]+x==y?0:1
*
2. 删除他 dp[x-1][y]+1 (x-1 匹配到y 删除一个)
*
3. 添加他 dp[x][y-1]+1 (我的x位置匹配到y-1 然后再增加一个y)

参考：

https://leetcode-cn.com/problems/edit-distance/comments/

20190727

我们的目的是让问题简单化，比如说两个单词 horse 和 ros 计算他们之间的编辑距离 D，容易发现，如果把单词变短会让这个问题变得简单，很自然的想到用 D[n][m] 表示输入单词长度为 n 和 m 的编辑距离。

具体来说，D[i][j] 表示 word1 的前 i 个字母和 word2 的前 j 个字母之间的编辑距离。