【代码随想录训练营第42期 Day45打卡 - 编辑距离问题 - LeetCode 115.不同的子序列 583. 两个字符串的删除操作 72. 编辑距离

逝去的秋风

于 2024-08-31 20:05:27 发布

阅读量1.1k

点赞数 25

分类专栏：代码随想录打卡文章标签： leetcode 动态规划编辑距离

本文链接：https://blog.csdn.net/2303_79786049/article/details/141721874

版权

代码随想录打卡专栏收录该内容

57 篇文章 0 订阅

订阅专栏

一、编辑距离问题总结

编辑距离问题是动态规划算法的一个重要应用，这类问题以 72. 编辑距离 - 力扣（LeetCode）最为经典。

这里对这类问题的处理做一个步骤上的小结（以 72.编辑距离为基准）：

1. 定义dp数组

定义一个二维数组dp，其中dp[i][j]表示字符串s1的前i个字符转换成字符串s2的前j个字符所需的最小编辑距离。

2. dp数组状态初始化

dp[0][j]：表示空字符串转换为s2的前j个字符，需要j次插入操作。

dp[i][0]：表示s1的前i个字符转换为空字符串，需要i次删除操作。

3. 状态转移方程

对于dp[i][j]，我们考虑s1[i-1]和s2[j-1]（即s1的第i个字符和s2的第j个字符）的匹配情况：

如果匹配：s1[i-1] == s2[j-1]，则无需编辑，dp[i][j] = dp[i-1][j-1]。

如果不匹配：s1[i-1] != s2[j-1]，则需要考虑以下三种操作，并取最小值：

插入：在s1中插入一个字符以匹配s2[j-1]，dp[i][j] = dp[i][j-1] + 1。

删除：删除s1中的字符s1[i-1]，dp[i][j] = dp[i-1][j] + 1。

替换：将s1中的字符s1[i-1]替换为s2[j-1]，dp[i][j] = dp[i-1][j-1] + 1。

4. 遍历顺序

动态规划的顺序是从左到右，从上到下计算dp数组。 -- 正序

5. 返回结果

最终，dp[s1.length()][s2.length()]将给出将整个s1转换为s2所需的最小编辑距离。

这便是对于这类问题的小结，其实也是对于今天打卡题目 72. 编辑距离 - 力扣（LeetCode）的小结。我们在处理这类问题的时候可以按照这样的思路进行。

二、题目与题解

题目一：115.不同的子序列

题目链接

115. 不同的子序列 - 力扣（LeetCode）

给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。

示例 1：
输入：s = "rabbbit", t = "rabbit"
输出：3
解释：
如下所示, 有 3 种可以从 s 中得到 "rabbit" 的方案
。
rabbbit
rabbbit
rabbbit
示例 2：
输入：s = "babgbag", t = "bag"
输出：5
解释：
如下所示, 有 5 种可以从 s 中得到 "bag" 的方案。 
babgbag
babgbag
babgbag
babgbag
babgbag
提示：

1 <= s.length, t.length <= 1000
s 和 t 由英文字母组成

题解：动态规划

这题和昨天打卡的 392. 判断子序列 - 力扣（LeetCode）相似。

昨天思路就按照上边总结的即可。

这里需要清楚状态方程的确立：

1.当前字符匹配（s[i - 1] 与 t[j - 1]），有两种情况 -- 这里求个数，即两种情况都得考虑：

（1）.不选择s[i-1]，则子序列个数dp[i-1][j]

（2）.选择s[i-1]，则子序列个数dp[i-1][j-1] -- 注意：这里是针对子序列的个数，而不是长度，在原有基础上多选择一个元素，个数不变，不用+1

2.当前字符不匹配，忽略（跳过）s当前字符 -- 昨天的打卡已经提到。

状态方程如下：

                if (s[i - 1] == t[j - 1]) {    
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                }
                else {            //当前字符不匹配，忽略（跳过）s当前字符
                    dp[i][j] = dp[i - 1][j];

这题还需要注意一个点：题目要求结果对 109 + 7 取模，但实际上最后是给数据开的足够大即可，我们对于 dp 数组开 unsigned long long 就行。

完整代码如下：

class Solution {
public:
    int numDistinct(string s, string t) {
        int n = s.size();
        int m = t.size();
        if (n < m) {          //子序列不可能长度更大
            return 0;
        }
        vector<vector<unsigned long long>> dp(n + 1, vector<unsigned long long>(m + 1, 0));   //dp[i][j]：以i-1为结尾的s子序列（s的前i个字符）中出现以j-1为结尾的t（t的前j个字符）的个数为dp[i][j]
        for(int i = 0; i <= n; i++) {       //初始化dp数组：当t为空字符串时，s中有1种方式匹配（即不选择任何字符）
            dp[i][0] = 1;
        } 
        for(int i = 1; i <= n; i++) {
            for(int j = 1; j <= m; j++) {
                //当前字符匹配（s[i - 1] 与 t[j - 1]），有两种情况 -- 这里求个数，即两种情况都得考虑：
                //1.不选择s[i-1]，则子序列个数dp[i-1][j]
                //2.选择s[i-1]，则子序列个数dp[i-1][j-1] -- 注意：这里是针对子序列的个数，而不是长度，在原有基础上多选择一个元素，个数不变，不用+1
                if (s[i - 1] == t[j - 1]) {    
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                }
                else {            //当前字符不匹配，忽略（跳过）s当前字符
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[n][m];
    }
};

题目二：583. 两个字符串的删除操作

题目链接

583. 两个字符串的删除操作 - 力扣（LeetCode）

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

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

示例 1：
输入: word1 = "sea", word2 = "eat"
输出: 2
解释: 第一步将 "sea" 变为 "ea" ，第二步将 "eat "变为 "ea"
示例 2:
输入：word1 = "leetcode", word2 = "etco"
输出：4
提示：

1 <= word1.length, word2.length <= 500
word1 和 word2 只包含小写英文字母

题解1：最长公共子序列变形

我们之前打卡过 1143. 最长公共子序列 - 力扣（LeetCode）这一道题。

而现在这一道题其实就可以理解为之前那道的变形：题目通过删除元素使两者相同且使删除的步数最少，那么我们可以发现完成删除元素之后即是原来两个字符串的最长公共子序列 -- 这时，最小步数就为：两单词的长度和 - 2 * 最长公共子序列长度。

理清题意后，这题就简单了：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n = word1.size();
        int m = word2.size();
        //求最长公共子序列长度：dp[n][m]
        vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));       //dp[i][j]：word1 前 i 个字符（0, i-1）与 word2 前 j 个字符（0, j-1）的最长公共子序列的长度
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                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 n + m - 2*dp[n][m];  //最小步数：(n - dp[n][m]) + (m - dp[n][m])
    }
};

题解2：编辑问题模板

这里其实就跟上边总结的内容几乎一致。

需要理解的一个点就是：word1 插入一个元素等价于 word2 删除一个元素，这里只有删除操作，但完全可以按照删除和插入两个操作来看，这样基本就和总结的模板差不多。

对于字符不匹配时，有以下几种情况：

1.删除word1[i - 1]，最少操作次数为dp[i - 1][j] + 1

2.删除word2[j - 1]，最少操作次数为dp[i][j - 1] + 1

3.同时删除word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2 -- 情况3实则被包含在前两种情况内，且步数更多，故取最小步数时，可以不考虑

代码如下：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n = word1.size();
        int m = word2.size();
        vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));   //dp[i][j]：以i-1为结尾（前 i 个元素）的字符串word1，和以j-1为结尾（前 j 个元素）的字符串word2，想要达到相等，所需要删除元素的最小步数
        //初始化dp数组
        for (int i = 1; i <= n; i++) {  //当word2为空字符串时，将word1转换为word2需要删除i个字符 -- 全部删掉
            dp[i][0] = i;
        }
        for (int j = 1; j <= m; j++) {      //当word1为空字符串时，将word2转换为word1需要删除j个字符 -- 全部删掉
            dp[0][j] = j;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (word1[i - 1] == word2[j - 1]) {         //当前字符匹配（相同），则无需删除
                    dp[i][j] = dp[i - 1][j - 1];
                } 
                //当前字符不匹配（不同）时，删除元素共有3种情况：
                //  1.删除word1[i - 1]，最少操作次数为dp[i - 1][j] + 1
                //  2.删除word2[j - 1]，最少操作次数为dp[i][j - 1] + 1
                //  3.同时删除word1[i - 1]和word2[j - 1]，操作的最少次数为dp[i - 1][j - 1] + 2 -- 情况3实则被包含在前两种情况内，且步数更多，故取最小步数时，可以不考虑
                else {     
                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
                }
            }
        }
        return dp[n][m];
    }
};

题目三：72. 编辑距离

题目链接

72. 编辑距离 - 力扣（LeetCode）

给你两个单词 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 由小写英文字母组成

题解：动态规划

这就是总结的经典模板题，重点就是删除，插入，替换三个操作的使用。

代码如下（含详细注释）：

class Solution {
public:
    int minDistance(string word1, string word2) {
        int n = word1.size();
        int m = word2.size();
        vector<vector<int>> dp(n + 1,vector<int>(m + 1, 0));    //dp[i][j]：以i-1为结尾（前 i 个元素）的字符串word1，和以j-1为结尾（前 j 个元素）的字符串word2，想要达到相等，所需要操作的最小步数
        /*  初始化dp数组  */
        for (int i = 1; i <= n; i++) {              //word2为空时，word1删除当前所有元素（i）转换为word2
            dp[i][0] = i;
        }
        for (int j = 1; j <= m; j++) {      //word1为空时，word2删除当前所有元素（j）转换为word1
            dp[0][j] = j;
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (word1[i - 1] == word2[j - 1]) {         //当前字符匹配，则无需编辑
                    dp[i][j] = dp[i - 1][j - 1];
                }
                /*当前字符不匹配，有三种情况：
                1.删除word1[i - 1]，即dp[i - 1][j] + 1 -- 等价于在word2中插入元素word1[i - 1] 
                2.删除word2[j - 1]，即dp[i][j - 1] + 1 -- 等价于在word1中插入元素word2[j - 1]
                3.替换word1的第i个字符 word1[i - 1] 与 word2的第j个字符 word2[j - 1]，即dp[i - 1][j - 1] + 1
                取三者最小值，即是最小操作数
                */
                else {
                    dp[i][j] = min(dp[i - 1][j - 1] + 1, min(dp[i - 1][j] + 1, dp[i][j - 1] + 1));
                }
            }
        }
        return dp[n][m];
    }
};