[LeetCode] 72、编辑距离

题目描述

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

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

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

示例：

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

解题思路

难，但是经常考！解决两个字符串的动态规划问题，一般都是用两个指针 i,j 分别指向两个字符串的最后，然后一步步往前走，缩小问题的规模（首先明确把s1变为s2和把s2变为s1所需要的“编辑距离”是一样的，所以拿谁做基准都可以）。上面的思路是“递归”的思路，自顶向下。（注意递归的优化无非是加备忘录memo或者DP table）。所以只要能写出递归的代码，如果递归代码有重复子问题（要知道如何判断此递归代码是否有重复子问题），就可以通过加备忘录memo（自顶向下）或者DP table（自底向上）来优化代码。

• 自顶向下加备忘录的代码见博客。

• 动态规划（公众号很多好文章）：

  • dp[i][j] 代表 word1 到 i 位置转换成 word2 到 j 位置需要最少步数

  • 所以：

    • 当 word1[i] == word2[j]，dp[i][j] = dp[i-1][j-1]；

    • 当 word1[i] != word2[j]，dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1 ，其中，dp[i-1][j-1] 表示替换操作，dp[i-1][j] 表示删除操作，dp[i][j-1] 表示插入操作。

    • 注意，针对第一行，第一列要单独考虑，我们引入 '' 下图所示：（首先要明确 dp 数组的含义，dp 数组是一个二维数组，长这样：）

      

      第一行，是 word1 为空变成 word2 最少步数，就是插入操作。

      第一列，是 word2 为空，需要的最少步数，就是删除操作。

  补充：（引用评论）

  对“dp[i-1][j-1] 表示替换操作，dp[i-1][j] 表示删除操作，dp[i][j-1] 表示插入操作。”的补充理解：

  以 word1 为 “horse”，word2 为 “ros”，且 dp[5][3] 为例，即要将 word1的前 5 个字符转换为 word2的前 3 个字符，也就是将 horse 转换为 ros，因此有：

  (1) dp[i-1][j-1]，即先将 word1 的前 4 个字符 hors 转换为 word2 的前 2 个字符 ro，然后将第五个字符 word1[4]（因为下标基数以 0 开始） 由 e 替换为 s（即替换为 word2 的第三个字符，word2[2]）

  (2) dp[i][j-1]，即先将 word1 的前 5 个字符 horse 转换为 word2 的前 2 个字符 ro，然后在末尾补充一个 s，即插入操作

  (3) dp[i-1][j]，即先将 word1 的前 4 个字符 hors 转换为 word2 的前 3 个字符 ros，然后删除 word1 的第 5 个字符

参考代码

带备忘录的递归

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size();
        int len2 = word2.size();
        if(len1 == 0)
            return len2;
        if(len2 == 0)
            return len1;

        vector<vector<int> > memo(len1, vector<int>(len2, -1));  // 这里不可以用二维数组，传参麻烦  https://www.cnblogs.com/huipengly/p/8892110.html
        int res = minDistanceRecursively(word1, word2, len1 - 1, len2 - 1, memo);
        
        return memo[len1-1][len2-1]; 
    }
    
    int minDistanceRecursively(string &word1, string &word2, int i, int j, vector<vector<int> > &memo){
        if(i == -1)
            return j + 1;
        if(j == -1)
            return i + 1;
        if(memo[i][j] != -1)
            return memo[i][j];
        
        if(word1[i] == word2[j]){
            memo[i][j] = minDistanceRecursively(word1, word2, i - 1, j - 1, memo);;
        }else{
            memo[i][j] = mMin(minDistanceRecursively(word1, word2, i, j - 1, memo),
                              minDistanceRecursively(word1, word2, i - 1, j, memo),
                              minDistanceRecursively(word1, word2, i - 1, j - 1, memo)) + 1;   // 别忘记+1
        }
        
        return memo[i][j];
    } 
    
    int mMin(int a, int b, int c){
        int tmp = a < b? a: b;
        return tmp < c? tmp: c;
    }
    
};

DP（推荐）

class Solution {
public:
    int minDistance(string word1, string word2) {
        int len1 = word1.size();
        int len2 = word2.size();
        if (word1.empty()) {
            return len2;
        }
        if (word2.empty()) {
            return len1;
        }
        // 由dp table可知，初始化好dp矩阵第一行和第一列后，其默认值并不重要。
        vector<vector<int>> dp(len1+1, vector<int>(len2+1, 0));
        // 初始化二维数组的第1行和第1列
        // base case 是 i 走完 s1 或 j 走完 s2，可以直接返回另一个字符串剩下的长度。
        for (int i = 1; i <= len1; i++) {
            dp[i][0] = i;
        }
        for (int j = 1; j <= len2; j++) {
            dp[0][j] = j;
        }
        // 自底向上求解
        for (int i = 1; i <= len1; i++) {
            for (int j = 1; j <= len2; j++) {
                if (word1[i-1] == word2[j-1]) {
                    dp[i][j] = dp[i-1][j-1];
                } else {
                    dp[i][j] = min(min(dp[i][j-1], dp[i-1][j]), dp[i-1][j-1]) + 1;  // 增删改3种情况，别忘记+1
                }
            }
        }
        // 储存着整个 word1 和 word2 的最小编辑距离
        return dp[len1][len2];
    }
};