Studying-代码随想录训练营day45| 115.不同的子序列、583. 两个字符串的删除操作、72. 编辑距离、编辑距离总结篇

最新推荐文章于 2024-10-03 13:36:06 发布

yachihaoteng

最新推荐文章于 2024-10-03 13:36:06 发布

阅读量1.1k

点赞数 17

文章标签：算法 c++ leetcode 动态规划数据结构

本文链接：https://blog.csdn.net/yachihaoteng/article/details/140698356

版权

第45天，子序列part03，编辑距离💪(ง •_•)ง，编程语言：C++

115.不同的子序列

文档讲解：代码随想录不同的子序列

视频讲解：手撕不同的子序列

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

学习：本题是392.判断子序列题目的扩展，本题需要求t在s中出现的次数。首先我们需要确定的就是t是否在s中出现。本题如果不是子序列，而是连续序列，可以考虑采用KMP算法进行求解。

从动归五部曲出发进行求解：

1.确定dp数组，以及下标的含义：本题可设置一个二维数组，dp[i][j]表示以i - 1为结尾的s的子序列中以j - 1为结尾的t出现的个数为dp[i][j]。

2.确定递归公式：首先我们在遍历的过程中需要判断的是s[i - 1] 和 t[j - 1]是否相等。假如相等，那么首先可以确定dp[i][j] 是可以由 dp[i - 1][j - 1]推导而来；其次还可以由dp[i - 1][j]推导而来。此处的含义就在于，是否要使用s[i - 1] = t[j - 1]，如果不使用这个，我们就需要dp[i - 1][j]来判断，如果使用则是dp[i - 1][j - 1]，最后得到：dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]

如果s[i - 1]与t[i - 1]不等，则说明当前未匹配，我们只能依靠dp[i - 1][j]。

3.初始化dp数组：显然根据递推公式，我们需要初始化第一行和第一列。第一行表示s为空串的时候，t出现的个数，显然为0；第一列表示t为空串的时候，在s中出现的个数，显然为1个。因此我们可在创建数组的时候，初始化为0，后把第一列，赋值为1，

4.确定遍历顺序，根据递推公式，我们需要依靠上方和左上方的元素，因此我们应该从上到下，从左到右进行遍历。

5.举例推导dp数组：

代码：

//时间复杂度O(m*n)
//空间复杂度O(m*n)
class Solution {
public:
    int numDistinct(string s, string t) {
        //动态规划，难题，很难
        //1.设置dp数组以及下标的含义
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1, 0));
        //2.确定递推公式
        //当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
        //当s[i - 1] 与 t[j - 1]不相等时，dp[i][j] = dp[i - 1][j];
        //3.初始化dp数组：初始化第一行和第一列
        //dp[i][0] 表示空字符串，[0-(i-1)]出现的个数，显然为1
        for(int i = 0; i <= s.size(); i++) {
            dp[i][0] = 1;
        }
        //dp[0][j] 表示[0-(j-1)]，在空字符串中出现的个数，显然为0
        //4.确定遍历顺序
        for(int i = 1; i <= s.size(); i++) {
            for(int j = 1; j <= t.size(); j++) {
                if(s[i - 1] == t[j - 1]) {
                    dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]);
                }
                else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[s.size()][t.size()];
    }

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

文档讲解：代码随想录两个字符串的删除操作

视频讲解：手撕两个字符串的删除操作

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

学习：首先本题有一个直观的思路，本题要通过删除字符使得两个字符串相同，则我们可以先求得两个字符串的最长公共子序列。之后每个字符串都需要删减到最长公共子序列的长度即可，最后所需要的最小步数就为：两个字符串的长度之和 - 最长公共子序列*2。

其次本题还可以通过动态规划的办法进行求解：

1.确定dp数组以及下标的含义：本题我们同样可以设置一个二维dp数组，dp[i][j]表示以 i - 1结尾的字符串word1和以 j - 1结尾的字符串word2相同所需要的最少步骤。

2.确定递推公式：首先遍历过程需要判断的是word1[i - 1] 和 word2[j - 1]是否相等。

如果word1[i - 1]与word2[j - 1]相等，则说明当前元素的是相同，那么我们只要保证前面的元素相同就行，因此最少步骤应该为dp[i - 1][j - 1]；

如果word1[i - 1]与word2[j - 1]不相等，则说明当前元素是不等的，我们需要进行删除操作。我们可以选择删除word1[i-1[也可以选择删除word2[j-1]，当然我们也可以选择两个都删除，只不过，两个都删除的情况，是包含在每个单独删除的情况里面的。然后我们选最少的步骤，则应该是：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i][j] + 2)

3.递推公式初始化：根据递推公式，我们需要依靠左上方，上方，和左边的元素，因此我们应该初始化第一行和第一列。首先第一行表示：word1在是空串的时候，word2需要进行删除的操作，显然word2需要删除到成为空串，则应该是dp[0][j] = j。同理第一列表示word2为空串的时候，则dp[i][0] = i;

4.确定遍历顺序：显然需要从上到下，从左到右进行遍历。

5.举例推导dp数组：

代码：

//时间复杂度O(n*m)
//空间复杂度O(n*m)
class Solution {
public:
    int minDistance(string word1, string word2) {
        //动态规划，难题
        //1.确定dp数组以及下标的含义
        vector<vector<int>> dp(word1.size() + 1, vector<int> (word2.size() + 1, 0));
        //2.确定递推公式：判断两种情况
        //当word1[i - 1] 与 word2[j - 1]相同的时候：dp[i][j] = dp[i - 1][j - 1];
        //当word1[i - 1] 与 word2[j - 1]不相同的时候：dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
        //3.初始化dp数组，初始化第一行和第一列
        for(int i = 0; i <= word1.size(); i++) {
            dp[i][0] = i;
        }
        for(int j = 0; j <= word2.size(); j++) {
            dp[0][j] = j;
        }
        //4.确定遍历顺序
        for(int i = 1; i <= word1.size(); i++) {
            for(int j = 1; j <= word2.size(); j++) {
                if(word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                else {
                    dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};

72. 编辑距离

文档讲解：代码随想录编辑距离

视频讲解：手撕编辑距离

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

学习：本题是前面题目的集大成之题，是动态规划解决的经典题目之一。本题允许删除，替换，插入三个操作。前面的题型一般只包含一个字符串的删除操作，或者两个字符串的删除操作，因此本题实际上只是对于字符串需要考虑的操作要多一项。

从动归五部曲出发进行分析：

1.确定dp数组以及下标的含义：本题我们可以设置一个二维dp数组，dp[i][j]表示以i - 1结尾的字符串word1，和以j - 1结尾的字符串word2，最近的编辑距离为dp[i][j](变成相同字符串所需要的步骤）。

2.确定递推公式：我们在遍历的过程中，同样是需要比较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]，也可以选择删除word2[j - 1]；对于替换来说就是将当前的数替换为相等的，则应该是dp[i-1][j - 1] + 1; 综上：dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));

3.初始化dp数组，显然我们需要初始化第一行和第一列，对于第一行来说，表示word1为空时，需要的操作，显然dp[0][j] = j; 对于第一列来说，表示word2为空时，需要的操作，显然dp[i][0] = i。

4.确定遍历顺序，显然我们需要从上往下，从左往右进行遍历

5.距离dp数组：

代码：

//时间复杂度O(n*m)
//空间复杂度O(n*m)
class Solution {
public:
    int minDistance(string word1, string word2) {
        //动态规划，很难
        //1.确定dp数组以及下标含义
        vector<vector<int>> dp(word1.size() + 1, vector<int> (word2.size() + 1, 0));
        //2.确定递推公式
        //3.初始化dp数组：初始化行和列
        for(int i = 0; i <= word1.size(); i++) {
            dp[i][0] = i;
        }
        for(int j = 0; j <= word2.size(); j++) {
            dp[0][j] = j;
        }
        //4.确定遍历顺序
        for(int i = 1; i <= word1.size(); i++) {
            for(int j = 1; j <= word2.size(); j++) {
                if(word1[i - 1] == word2[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1];
                }
                else {
                    dp[i][j] = min(dp[i - 1][j] + 1, min(dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1));
                }
            }
        }
        return dp[word1.size()][word2.size()];
    }
};