Leetcode 583. 两个字符串的删除操作

题目链接：583 两个字符串的删除操作

题干：给定两个单词 word1 和 word2 ，返回使得 word1 和  word2 相同所需的最小步数。

每步 可以删除任意一个字符串中的一个字符。

思考：动态规划。本题中的步数可以看作删除字母，使得两单词最终处理为相同字母组。

• 确定dp数组（dp table）以及下标的含义

dp[i][j]：使得 以i - 1结尾的单词word1和以j - 1结尾的单词word2 相同所需的最小步数。

• 确定递推公式

从dp[i][j]的定义可以看出，字母比较就两种情况

• 当word1[i - 1] 与 word2[j - 1]相同的时候
• 当word1[i - 1] 与 word2[j - 1]不相同的时候

当word1[i - 1] 与 word2[j - 1]相同的时候，dp[i][j] = dp[i - 1][j - 1];

当word1[i - 1] 与 word2[j - 1]不相同的时候，有三种情况：

情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1

情况二：删word2[j - 1]，最少操作次数为dp[i][j - 1] + 1

情况三：同时删word1[i - 1]和word2[j - 1]，最少的操作次数为dp[i - 1][j - 1] + 2

当然要取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 2, dp[i - 1][j] + 1, dp[i][j - 1] + 1});

又因为 dp[i][j - 1] + 1 = dp[i - 1][j - 1] + 2，所以递推公式可简化为：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);

• dp数组如何初始化

从递推公式中，可以看出来，dp[i][0] 和 dp[0][j]是一定要初始化的。

dp[i][0]：word2为空字符串，以i-1为结尾的字符串word1要删除多少个元素，才能和word2相同呢，很明显dp[i][0] = i。同理 dp[0][j] = j。

• 确定遍历顺序

从递推公式 dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1; 和dp[i][j] = dp[i - 1][j - 1]可以看出dp[i][j]都是根据左上方、正上方、正左方推出来的。

所以遍历的时候一定是从上到下，从左到右，这样保证dp[i][j]可以根据之前计算出来的数值进行计算。

• 举例推导dp数组

举例：word1:"sea"，word2:"eat"，推导dp数组状态图如下：

代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        //dp[i][j]:使得 以i - 1结尾的单词word1和以j - 1结尾的单词word2 相同所需的最小步数 
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
        for (int i = 1; i <= word1.size(); i++)     //单词word2为空的情况
            dp[i][0] = i;
        for (int j = 1; j <= word2.size(); j++)     //单词word1为空的情况
            dp[0][j] = j;

        for (int i = 1; i <= word1.size(); i++) {           //遍历单词word1
            for(int j = 1; j <= word2.size(); j++) {        //遍历单词word2
                if (word1[i - 1] == word2[j - 1])
                    dp[i][j] = dp[i - 1][j - 1];        //字母相同则无需无需删除字母
                else
                    dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + 1;     //字母不相同则选一单词删除字母，取最小值
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

思考：动态规划。本题也可以从求公共子序列入手，要删除的元素个数（即步数）为两单词长度减去两倍公共子序列长度。具体如何求公共子序列：1143 最长公共子序列。

代码： 

class Solution {
public:
    int minDistance(string word1, string word2) {
        //dp[i][j]:单词word1的处理区间[0, i - 1]与单词word2的处理区间[0, j - 1]中，存在的最长公共子序列的长度
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1, 0));     

        for (int i = 1; i <= word1.size(); i++) {           //遍历单词word1
            for (int j = 1; j <= word2.size(); j++) {       //遍历单词word2
                if (word1[i - 1] == word2[j - 1])
                    //当前处理两字母相等 则 取两单词均缩小处理区间的最长公共子序列长度加一
                    dp[i][j] = dp[i - 1][j - 1] + 1;        
                else 
                    //当前处理两字母不相等 则 取任选一单词缩小处理区间的最长公共子序列长度，两长度中的较大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);     
            }
        }
        return word1.size() + word2.size() - 2 * dp[word1.size()][word2.size()];        //两单词去除最长公共子序列
    }
};

Leetcode 72. 编辑距离

题目链接：72 编辑距离

题干：给你两个单词 word1 和 word2， 请返回将 word1 转换成 word2 所使用的最少操作数  。你可以对一个单词进行如下三种操作：

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

思考：动态规划。本题要先想清楚：真正要求的是将word1和word2变成相同单词的操作次数。

题干中删除word1字母的操作 可以等价为 插入word2字母的操作；插入word1字母的操作 可以等价为 删除word2字母的操作。下面就直接考虑删除操作不考虑插入操作。

因此本题与上题的区别在 确定递推公式中：

当word1[i - 1] 与 word2[j - 1]不相同的时候，有不同的三种操作：

情况一：删word1[i - 1]，最少操作次数为dp[i - 1][j] + 1

情况二：删word2[j - 1](同向word1中插入)，最少操作次数为dp[i][j - 1] + 1

情况三：替换word1[i - 1]，最少的操作次数为dp[i - 1][j - 1] + 1

当然要取最小值，所以当word1[i - 1] 与 word2[j - 1]不相同的时候，递推公式：dp[i][j] = min({dp[i - 1][j - 1] + 1, dp[i - 1][j] + 1, dp[i][j - 1] + 1});

代码：

class Solution {
public:
    int minDistance(string word1, string word2) {
        //dp[i][j]:对以i- 1结尾的单词word1和以j - 1结尾的单词word2操作，让处理后两单词相同的最少操作次数
        vector<vector<int>> dp(word1.size() + 1, vector<int>(word2.size() + 1));
        
        for (int i = 0; i <= word1.size(); i++)     //单词word2为空的情况
            dp[i][0] = i;
        for (int j = 1; j <= word2.size(); j++)     //单词word1为空的情况
            dp[0][j] = j;

        for (int i = 1; i <= word1.size(); i++) {           //遍历单词word1
            for (int j = 1; j <= word2.size(); j++) {       //遍历单词word2
                if (word1[i - 1] == word2[j - 1])
                    //当前两字母相同则不用处理
                    dp[i][j] = dp[i - 1][j - 1];    
                else
                    //当前两字母不同则考虑替换word1的字母，删除word1的字母以及删除word2的字母
                    dp[i][j] = min(dp[i - 1][j - 1], min(dp[i - 1][j], dp[i][j -1])) + 1;
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

自我总结：

        理解公共子序列问题的关键在于删除操作，两字符串的操作含义同dp数组的含义变化而变化。动态规划是在每次操作中考虑每种情况，统一处理。