代码随想录算法训练营第五十四天| LeetCode392.判断子序列、115.不同的子序列

一、LeetCode392.判断子序列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0392.%E5%88%A4%E6%96%AD%E5%AD%90%E5%BA%8F%E5%88%97.html

状态：已解决

1.思路 

        此题是编辑距离问题的入门题。编辑距离指的是对数组进行增加、替换、删除操作，此题只有删除操作。使用动规五部曲分析：

（1）确定dp数组以及下标含义：

        dp[i][j]： 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

        这里表示以下标 i-1 为结尾的字符串的原因跟上上篇博客718题的原因一致，本质是为了简化初始化过程，

（2）确定递推公式：

        dp[i][j]的取值有两种情况：

①  if (s[i - 1] == t[j - 1])：代表 t 中找到了一个跟 s 相匹配的字符

② if (s[i - 1] != t[j - 1])：代表 t 要删除元素，继续进行匹配

        if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，因为找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1（如果不理解，再回看一下dp[i][j]的定义）

        if (s[i - 1] != t[j - 1])，此时相当于t要删除元素，t如果把当前元素t[j - 1]删除，那么dp[i][j] 的数值就是 看s[i - 1]与 t[j - 2]的比较结果了，即：dp[i][j] = dp[i][j - 1]；注意这里不要求删除s，因为s是固定串，故与1143.最长公共子序列题不同，只有左边推过来。

（3）初始化dp数组：

        从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，所以dp[0][0]和dp[i][0]是一定要初始化的。由于dp[i][0]和dp[0][j]代表一个串长度为0，因此能匹配的长度也就为0，故二者初始化为0，同时其余下标均被覆盖，故可统一初始化为0。

（4）确定遍历顺序：

        从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，所以遍历的时候就要从小到大，从上到下，即：两层循环都从小到大。

（5）举例推导dp数组：

 以示例一为例，输入：s = "abc", t = "ahbgdc"，dp状态转移图如下：

dp[i][j]表示以下标i-1为结尾的字符串s和以下标j-1为结尾的字符串t 相同子序列的长度，所以如果dp[s.size()][t.size()] 与 字符串s的长度相同说明：s与t的最长相同子序列就是s，那么s 就是 t 的子序列。故最后返回 dp[s.size()][t.size()] == s.size()

2.代码实现 

        这里为了符合为自己的习惯，依旧是统一把递推公式往后移动一位，用加法表示前一位和后一位。

class Solution {
public:
    bool isSubsequence(string s, string t) {
        vector<vector<int>> dp(s.size()+1,vector<int>(t.size()+1,0));
        for(int i=0;i<s.size();i++){
            for(int j=0;j<t.size();j++){
                if(s[i] == t[j]){
                    dp[i+1][j+1] = dp[i][j] + 1;
                }else{
                    dp[i+1][j+1] = dp[i+1][j];
                }
            }
        }
        return dp[s.size()][t.size()] == s.size();
    }
};

时间复杂度：O(n × m)

空间复杂度：O(n × m)

二、115.不同的子序列

题目链接/文章讲解/视频讲解：https://programmercarl.com/0115.%E4%B8%8D%E5%90%8C%E7%9A%84%E5%AD%90%E5%BA%8F%E5%88%97.html

状态：已解决

1.思路 

        使用动规五部曲：

（1）确定dp数组以及下标含义：

        dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

（2）确定递推公式（比较难理解，我直接把文章这段摘下来了）：

        这一类问题要分两种情况：

• s[i - 1] 与 t[j - 1]相等：

  当s[i - 1] 与 t[j - 1]相等时，dp[i][j]可以有两部分组成。

  一部分是用s[i - 1]来匹配，那么个数为dp[i - 1][j - 1]。即不需要考虑当前s子串和t子串的最后一位字母，所以只需要 dp[i-1][j-1]。

  一部分是不用s[i - 1]来匹配，个数为dp[i - 1][j]。

  （例如： s：bagg 和 t：bag ，s[3] 和 t[2]是相同的，但是字符串s也可以不用s[3]来匹配，即用s[0]s[1]s[2]组成的bag。

  当然也可以用s[3]来匹配，即：s[0]s[1]s[3]组成的bag。）

        故dp[i][j] = dp[i-1][j]；

• s[i - 1] 与 t[j - 1] 不相等：

        dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]。

       故 dp[i][j] = dp[i-1][j]

（3）初始化dp数组：

      根据上面的递推公式，我们知道dp[i][j]可以由左上角、正上方而来，故dp[i][0] 和dp[0][j]是一定要初始化的。dp[i][0] 表示：以i-1为结尾的s串出现空字符串的个数。删除s中所有元素，就可以得到空字符串，故dp[i][0]的个数就是1。

      dp[0][j]：空字符串s中出现的以j-1为结尾的字符串t的个数。那么dp[0][j]一定都是0，s如论如何也变成不了t。

        dp[0][0]也初始化为1，因为两个空字符串天然相等；

        其余下标就初始化为0，反正会被覆盖

（4） 确定遍历顺序：

        从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j]都是根据左上角、正上方推出来的。因此遍历顺序由左到右、由上到下，即两层循环均由小到大。

（5）举例推导dp数组：

        以s："baegg"，t："bag"为例，推导dp数组状态如下：

2.代码实现 

class Solution {
public:
    int numDistinct(string s, string t) {
        vector<vector<uint64_t>> dp(s.size()+1,vector<uint64_t>(t.size()+1));
        //注意最后一个样例爆int了，故要将结果数组的类型开大一点
        for(int i=0;i<s.size();i++){
            dp[i][0] = 1;
        }
        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()];
    }
};

时间复杂度: O(n * m)

空间复杂度: O(n * m)