leetcode hot 100

72. 编辑距离

题目描述：

给你两个单词 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')

思路：动态规划

dp[][]数组，dp[i][j]表示word1的前i个字符转换成word2的前j个字符需要的最少操作次数

如果word1[i] == wrod2[j], 那么dp[i][j] = dp[i-1][j-1],即不需要进行任何额外操作

如果word1[i] != word2[j], 那么需要进行替换、插入、删除操作来使得word1的前i个字符转换成word2的前j个字符

• 如果采用替换操作，说明word1的前(i-1)个字符已经完全和word2的前(j-1)个字符匹配，只需把word1[i]替换成word2[j]即可，所以是在原来dp[i-1][j-1]的基础上加一
• 如果采用插入操作，说明word1的前i个字符已经和word2的前j-1个字符匹配，需要在word1中插入一个word2[j]来使得word1的前i个字符转换成word2的前j个字符， 所以是在原来dp[i][j-1]的基础上加一，即加上一个插入操作
• 如果采用删除操作，说明word1的前(i-1)个字符已经和word2的前j个字符匹配，word1[i]是多余的，所以是在dp[i-1][j]的基础上加一，即加上一个删除操作

所以转态转移方程为：

// word1的前i个字符等于word2的前j个字符，相当于是word1.charAt(i-1) == word2.charAt(j-1)
dp[i][j] = dp[i - 1][j - 1]; 
// word1的前i个字符不等于word2的前j个字符，相当于是word1.charAt(i-1) == word2.charAt(j-1)
dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i][j - 1]), dp[i - 1][j]) + 1; 

边界初始化

dp[0][j] = j;    // word1的前0个字符转换成word2的前j个字符，说明需要不断的往word1中插入字符，插入的操作数刚好等于i

dp[i][0] = i;    // word1的前i个字符转换成word2的前0个字符，说明需要不断的从word1中删除字符，删除的操作数刚好等于i

class Solution {
    public int minDistance(String word1, String word2) {

        int len1 = word1.length();
        int len2 = word2.length();

        int[][] dp = new int[len1+1][len2+1];
        // 初始化边界 dp[i][0] = i, dp[0][j] = j
        for(int i = 0; i <= len1; i++){
            dp[i][0] = i;
        }
        for(int j = 0; j <= len2; j++){
            dp[0][j] = j;
        }

        // 使用转态转移方程进行迭代
        // 注意因为我们转态转移方程中前i个字符其实对应了字符串的第i-1个字符，因为字符串是从0开始计数的
        for(int i = 1; i <= len1; i++){
            for(int j = 1; j <= len2; j++){
                if(word1.charAt(i-1) == word2.charAt(j-1)){
                    dp[i][j] = dp[i - 1][j - 1];
                }else{
                    dp[i][j] = Math.min(Math.min(dp[i - 1][j - 1], dp[i][j - 1]), dp[i - 1][j]) + 1;
                }
            }
        }
        return dp[len1][len2];
    }
}

leetcode 执行用时：7 ms > 46.75%, 内存消耗：38.4 MB > 99.32%

复杂度分析：

时间复杂度：两个for循环，循环次数分别为word1 的长度和 word2 的长度，所以时间复杂度为O(len1*len2)

空间复杂度：需要一个大小为len1*len2 的数组，所以空间复杂度也为 O(len1*len2)