100 编辑距离（Edit Distance）

1 题目

题目：编辑距离（Edit Distance）
描述：给出两个单词word1和word2，计算出将word1 转换为word2的最少操作次数。你可进行三种操作：插入一个字符；删除一个字符；替换一个字符。

lintcode题号——119，难度——medium

样例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')

2 解决方案

2.1 思路

  使用动态规划的方式解，将状态dp[i][j]定义为表示word1中的前i个转换为word2中的前j个的最少操作次数，则如果word1第i个与word2第j个相同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]三者中取最小值；如果word1第i个与word2第j个不同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]+1三者中取最小值，理清动态规划的四要素即可解出。

双序列型动态规划：由于将状态定义成前i个字符的状态，所以前0个对象的状态~前i个对象的状态，一共有i+1个状态，所以容器的长度需要增加一位，注意与坐标型动态规划区分。

2.3 时间复杂度

  算法会遍历二维数组，假设word1字符串和word2字符串的长度分别为m、n，则算法的时间复杂度为O(m*n)。

2.4 空间复杂度

  使用了二维数组数据结构，容量为m*n，空间复杂度为O(m*n)。

3 源码

细节：

1. 动态规划的四要素：状态、方程、初始化、答案。（四要素在之前的题目数字三角形¹中有详细介绍）
2. 状态：用dp[i][j]表示word1中的前i个转换为word2中的前j个的最少操作次数。
3. 方程：分两种情况，如果word1第i个与word2第j个相同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]三者中取最小值；如果word1第i个与word2第j个不同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]+1三者中取最小值。
4. 初始化：将空串转化为长度n字符的操作次数为n。
5. 答案：将word1所有字符转成word2所有字符的最少次数，即dp[maxI]dp[maxJ]。

C++版本：

/**
* @param word1: A string
* @param word2: A string
* @return: The minimum number of steps
*/
int minDistance(string &word1, string &word2) {
    // write your code here
    if (word1.empty())
    {
        return word2.size();
    }
    if (word2.empty())
    {
        return word1.size();
    }

    // 状态：dp[i][j]表示word1中的前i个转换为word2中的前j个的最少操作次数
    vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, INT_MAX));

    // 初始化：将空串转化为长度n字符的操作次数为n
    for (int i = 0; i < dp.size(); i++)
    {
        dp[i][0] = i;
    }
    for (int j = 0; j < dp.front().size(); j++)
    {
        dp[0][j] = j;
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 1; j < dp.front().size(); j++)
        {
            // 方程：如果word1第i个与word2第j个相同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]三者中取最小值
            if (word1[i - 1] == word2[j - 1]) // 第i个数下标i-1
            {
                dp[i][j] = min(dp[i][j - 1] + 1, dp[i - 1][j] + 1);
                dp[i][j] = min(dp[i - 1][j - 1], dp[i][j]);
            }
            else // 方程：如果word1第i个与word2第j个不同，则dp[i][j]在dp[i][j-1]+1、dp[i-1][j]+1、dp[i-1][j-1]+1三者中取最小值
            {
                dp[i][j] = min(dp[i][j - 1] + 1, dp[i - 1][j] + 1);
                dp[i][j] = min(dp[i - 1][j - 1] + 1, dp[i][j]);
            }
        }
    }

    return dp[dp.size() - 1][dp.front().size() - 1]; // 答案：将word1所有字符转成word2所有字符的最少次数
}

---

1. 数字三角形：https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎