力扣LeetCode #72 编辑距离（MinDistance）

最新推荐文章于 2023-11-12 08:00:00 发布

苏志林的情敌

最新推荐文章于 2023-11-12 08:00:00 发布

阅读量679

点赞数

文章标签： java 动态规划力扣算法

本文链接：https://blog.youkuaiyun.com/weixin_49155948/article/details/112946786

版权

该博客探讨了如何使用动态规划方法解决LeetCode上的#72 编辑距离问题，给出了从word1转换到word2的最少操作数。通过详细分析思路并展示JAVA代码实现，解释了动态规划的状态转移方程，并比较了两种初始化二维数组的方法，强调了其中一种方法的优势。

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

- 题目描述

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数。你可以对一个单词进行如下三种操作：

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

提示：

0 <= word1.length, word2.length <= 500
word1 和 word2 由小写英文字母组成

来源：LeetCode

- 示例

示例 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’)

- 思路分析

动态规划。定义 $d p [i] [j]$ : $w o r d 1$ 的前 $i$ 个字符转换为 $w o r d 2$ 的前 $j$ 个字符所需的最少改变次数。则根据题意，如果 $w o r d 1 [i] = = w o r d 2 [j]$ ，那么不需要额外的操作， $d p [i] [j] = d p [i - 1] [j - 1]$ ；如果 $w o r d 1 [i]! = w o r d 2 [j]$ ，那么无论是增、删、改，都需要一次操作，因此 $d p [i] [j] = M a t h . m i n (d p [i - 1] [j - 1], d p [i] [j - 1], d p [i - 1] [j]) + 1$ 。因此可得到动态转移方程：
$\begin{cases} dp[i-1][j-1],& \text{word1[i] == word2[j]}\\ 1+min(dp[i][j-1],dp[i-1][j],dp[i-1][j-1]& \text{word1[i]!=word2[j]} \end{cases}$
需要注意的是，初始化二维数组dp时，有两种方法：

$d p [w o r d 1 . l e n g t h ()] [w o r d 2 . l e n g t h ()]$ :
如果用这种方法，在处理边界i=0和j=0的情况时，需要特别注意形如"abab"和"b"的情况。当i = 3,j=0时，dp[i][j]不应该等于dp[i-1][j], 而应该是dp[i-1][j]+1，因为word2[0]的"b"已经和word1[1]的"b"匹配过了，因此这个b不能再和word1[3]的"b"匹配。因此这种方法会相对麻烦，不仅代码较长，而且效率也比较低。
$d p [w o r d 1 . l e n g t h () + 1] [w o r d 2 . l e n g t h () + 1]$ :
如果用这种方法，在初始化时相对简单，直接令 $d p [i] [0] = i$ , $d p [0] [j] = j$ 即可。而且这种方法规避了第一种方法会遇到的问题：当word1[i]==word2[j]时，dp[i][j] = dp[i-1][j-1]，这时已经默认了word1[i]是和word2[j]匹配，而不能和前面的相同字符匹配。这种方法代码简单，效率也比较高，而且容易理解。

- JAVA实现

class Solution {
    public int minDistance(String word1, String word2) {
        int len1 = word1.length(), len2 = word2.length();
        if(len1 == 0) return len2;
        if(len2 == 0) return len1;
        int[][] dp = new int[len2+1][len1+1];
        int i, j;

        /*如果用方法1计算dp，就很令人难受
        if(word1.charAt(0) == word2.charAt(0)) dp[0][0] = 0;
        else dp[0][0] = 1;
        boolean occur = false;  //用来保存这个单字符是否已经匹配过了
        for(i=1; i<len1; i++) {
            if(word1.charAt(i) == word2.charAt(0)) {
                if(occur == false) {
                    occur = true;
                    dp[0][i] = dp[0][i-1];
                }
                else dp[0][i] = 1 + dp[0][i-1];
            }
            else dp[0][i] = 1 + dp[0][i-1];
        }
            
        occur = false;    
        for(j=1; j<len2; j++) {
            if(word1.charAt(0) == word2.charAt(j)) {
                if(occur == false) {
                    occur = true;
                    dp[j][0] = dp[j-1][0];
                }
                else dp[j][0] = 1 + dp[j-1][0];
            }
            else dp[j][0] = 1 + dp[j-1][0]; 
        }
        */
        
        for(i=0; i<=len1; i++) dp[0][i] = i;
        for(j=0; j<=len2; j++) dp[j][0] = j;

        for(j=1; j<=len2; j++) {
            for(i=1; i<=len1; i++) {
                if(word1.charAt(i-1) == word2.charAt(j-1)) dp[j][i] = dp[j-1][i-1];//这里要用i-1和j-1来获取正确位置的字符
                else dp[j][i] = 1 + Math.min(dp[j-1][i], Math.min(dp[j][i-1], dp[j-1][i-1]));
            }
        }
        return dp[len2][len1];  
    }
}