LeetCode hot 100—编辑距离

题目

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

分析

这是一个经典的动态规划问题，也叫莱文斯坦距离（Levenshtein distance）。可以使用动态规划的方法来求解将 word1 转换成 word2 所使用的最少操作数。

动态规划

算法思路

定义状态
设 dp[i][j] 表示将 word1 的前 i 个字符转换成 word2 的前 j 个字符所需要的最少操作数。这里 i 和 j 的范围分别是从 0 到 word1.length() 和 word2.length()。

初始化边界条件

• 当 i = 0 时，意味着 word1 为空字符串，那么将空字符串转换成 word2 的前 j 个字符需要 j 次插入操作，所以 dp[0][j] = j。
• 当 j = 0 时，意味着 word2 为空字符串，那么将 word1 的前 i 个字符转换成空字符串需要 i 次删除操作，所以 dp[i][0] = i。

状态转移方程

• 如果 word1[i - 1] == word2[j - 1]，说明当前字符相等，不需要进行额外操作，那么 dp[i][j] = dp[i - 1][j - 1]。
• 如果 word1[i - 1] != word2[j - 1]，则可以进行三种操作：
• 插入操作：要使 word1 的前 i 个字符变成 word2 的前 j 个字符，可以先让 word1 的前 i 个字符变成 word2 的前 j - 1 个字符，再插入一个字符，即 dp[i][j] = dp[i][j - 1] + 1。
• 删除操作：先让 word1 的前 i - 1 个字符变成 word2 的前 j 个字符，再删除 word1 的第 i 个字符，即 dp[i][j] = dp[i - 1][j] + 1。
• 替换操作：先让 word1 的前 i - 1 个字符变成 word2 的前 j - 1 个字符，再将 word1 的第 i 个字符替换成 word2 的第 j 个字符，即 dp[i][j] = dp[i - 1][j - 1] + 1。
• 综合这三种操作，取最小值作为 dp[i][j] 的值，即 dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1)。

最终结果
最终结果为 dp[word1.length()][word2.length()]，即把 word1 的全部字符转换成 word2 的全部字符所需的最少操作数。

时间复杂度：O()， 是 word1 的长度， 为 word2 的长度

空间复杂度：O()

class Solution {
public:
    int minDistance(std::string word1, std::string word2) {
        int m = word1.length();
        int n = word2.length();
        // 创建 dp 数组
        std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));
        // 初始化
        for (int i = 0; i <= m; ++i) {
            dp[i][0] = i;
        }
        for (int j = 0; j <= n; ++j) {
            dp[0][j] = j;
        }
        // 填充 dp 数组
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                } else {
                    dp[i][j] = std::min({dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]}) + 1;
                }
            }
        }
        return dp[m][n];
    }
};