【一看就会一写就废指间算法】编辑距离 —— 动态规划题目：给你两个单词 word1 和 word2，请返回将 wo

指尖划过的轨迹，藏着最细腻的答案~

题目：

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

提示：

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

分析：

本题其实与最长公共子序列（传送门） 有很多相似的地方。最长公共子序列是找相同的数量，本题可以理解为是找不同的数量，如下。

动态规划一般分为3步走：

确定dp数组含义： 我们定义dp[i][j]为word1从下标(0, i)与word2从下标(0,j)的最少的操作数。最终答案即为dp[m-1][n-1]。
状态转移方程：

对于dp[i][j]来说，
- 如果word1[i] == word2[j]，此时不需要任何操作，dp[i][j] == dp[i-1][j-1];
- 如果word1[i] != word2[j]，我们思考怎样可以到达dp[i][j]呢？
  
  从i-1到达i，即只word1向后遍历；
  
  从j-1到达j，即只word2向后遍历；
  
  上面两种情况即 最长公共子序列（传送门） 种的公式，那本题还有其他的情况吗？
  
  当然，从(i-1,j-1)到达(i,j)，word1和word2向后遍历；这是为了增加(i-1,j-1)前面全相同的情况。
最终取上面三种情况中的最小值+1。

状态转移方程如下： $dp[i][j]= \begin{cases} dp[i-1][j-1] ,word1[i] == word2[j] \\ min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1, word1[i] != word2[j] \end{cases}$
初始化：
- 对于第一行：即i=0时，word1长度为0，此时，随着word2的遍历，需要修改(增加)的字符也应该跟随word2增加。
- 对于第一列：即j=0时，word2长度为0，此时，随着word1的遍历，需要修改(删除)的字符也应该跟随word1增加。
- 如果i=0与j=0时，上面状态转移方程不合法。因此我们可以在i=0的上面与j=0左边增加新的一行或一列数据，此时上面状态转移方程i需要变为i+1，i-1变为i，如下： $dp[i+1][j+1]= \begin{cases} dp[i][j],word1[i] == word2[j] \\ min(dp[i][j+1], dp[i+1][j],dp[i][j]) + 1, word1[i] != word2[j] \end{cases}$

AC代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));

        // 加1是因为插入了新的列与行
        for (int i = 0; i < m; i++) {
            dp[i+1][0] = i + 1;
        }
        for (int j = 0; j < n; j++) {
            dp[0][j+1] = j + 1;
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (word1[i] == word2[j]) {
                    dp[i+1][j+1] = dp[i][j];
                } else {
                    dp[i+1][j+1] = min({dp[i][j+1], dp[i+1][j], dp[i][j]}) + 1;
                }
            }
        }

        return dp[m][n];
    }
};

我们可以将j=0时的初始化，放在后面的双重循环中，这样可以减少一次循环，如下：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<vector<int>> dp(m+1, vector<int>(n+1, 0));

        // 加1是因为插入了新的列与行
        for (int j = 0; j < n; j++) {
            dp[0][j+1] = j + 1;
        }

        for (int i = 0; i < m; i++) {
            dp[i+1][0] = i + 1;
            for (int j = 0; j < n; j++) {
                if (word1[i] == word2[j]) {
                    dp[i+1][j+1] = dp[i][j];
                } else {
                    dp[i+1][j+1] = min({dp[i][j+1], dp[i+1][j], dp[i][j]}) + 1;
                }
            }
        }

        return dp[m][n];
    }
};

空间优化一：两个数组

我们可以观察到上面的状态转移方程只与i-1与j-1有关，因此我们可以使用两个数组来轮转记录前一次的状态。

class Solution {
public:
    int minDistance(string word1, string word2) {
        int m = word1.size(), n = word2.size();
        vector<vector<int>> dp(2, vector<int>(n+1, 0));

        // 加1是因为插入了新的列与行
        for (int j = 0; j < n; j++) {
            dp[0][j+1] = j + 1;
        }

        for (int i = 0; i < m; i++) {
            dp[(i + 1) % 2][0] = i + 1;
            for (int j = 0; j < n; j++) {
                if (word1[i] == word2[j]) {
                    dp[(i + 1) % 2][j+1] = dp[i % 2][j];
                } else {
                    dp[(i + 1) % 2][j+1] = min({dp[i % 2][j+1], dp[(i + 1) % 2][j], dp[i % 2][j]}) + 1;
                }
            }
        }

        return dp[m % 2][n];
    }
};

【一看就会一写就废 指间算法】编辑距离 —— 动态规划

题目：

分析：

AC代码：

空间优化一：两个数组

【一看就会一写就废指间算法】编辑距离 —— 动态规划