Day 54 392.判断子序列 115.不同的子序列

判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。

字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。

示例 1：

• 输入：s = “abc”, t = “ahbgdc”
• 输出：true

示例 2：

• 输入：s = “axc”, t = “ahbgdc”
• 输出：false

提示：

• 0 <= s.length <= 100
• 0 <= t.length <= 10^4

两个字符串都只由小写字符组成。

​ 掌握本题的动态规划解法是对后面的编辑距离的题目打下基础；

​ 1.dp数组下标及其含义

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

​ 2.递推公式

​ 由题目可知，这里只涉及了删除操作，所以

	if(s[i - 1] == t[j - 1]){//相同，在s和t中均出现，原有基础加一
        dp[i][j] = dp[i - 1][j - 1] + 1;
    }
	else{//不相同，那就保持t中之前比较的结果
        dp[i][j] = dp[i][j - 1];
    }

​ 3.初始化

​ 由递推公式，dp[i][j]是由左上角推出，所以第一行第一列初始化为0（因为dp数组定义）；

​ 4.遍历顺序

​ 从上到下，从左到右；

​ 5.打印dp

​ 整体代码如下

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 = 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] + 1;
                else dp[i][j] = dp[i][j - 1];
            }
        }
        if(dp[s.size()][t.size()] == s.size()){
            return true;
        }
        else return false;
    }
};

不同的子序列

给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。

字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的一个子序列，而 “AEC” 不是）

题目数据保证答案符合 32 位带符号整数范围。

提示：

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

​ 依然，为编辑距离问题做铺垫；

​ 1.确定dp数组（dp table）以及下标的含义

​ dp[i][j]： 表示 s 的前i 个字符（s[0:i-1]）中包含 t 的前 j 个字符（t[0:j-1]）的不同子序列的个数;

​ 2.递推公式

​ 当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[i - 1]来匹配，都相同了指定要匹配啊;

​ 例如： 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。

​ 所以当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];

	if(s[i - 1] == t[j - 1]){//如果相同
        //dp[i-1][j]可以看成在s[0,i-2]子序列中找t[0,j-1]中总共出现多少次，不包含 s[i-1]，那么子序列的个数就是 dp[i-1][j];不考虑i-1元素来匹配，此时s比t多退一格用来模拟删除i-1元素，即s[0, i - 2]为了防止负索引，只能是j加上1，dp[i-1][j]
    	//这一项其实不用管s[i - 1]和t[j - 1]到底相不相等，dp[i - 1][j]就是一个base;
        dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
        //包含s[i-1]，那么剩下的j-1个字符必须在s的前i-1个字符中，所以此时额外的子序列的个数是dp[i-1][j-1];
    }
	else{
        dp[i][j] = dp[i - 1][j];
        //当 s[i-1] != t[j-1] 时，我们只能选择不包含 s[i-1] 的情况，所以 dp[i][j] = dp[i-1][j]。

    }

​ 3.初始化

​ 当 j == 0 时，无论 i 是多少，dp[i][0] 都应该为 1，因为空字符串是任何字符串的子序列；
​ 当 i == 0 时，如果 j > 0，则 dp[0][j] 应该为 0，因为 s 是空的，无法包含 t 的任何非空子序列；

​ 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];
            }
        }
    }

​ 5.打印dp

​ 整体代码如下

class Solution {
public:
	int numDistinct(string s, string t){
        vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1, 0));
        //<uint64_t> 是一个类型模板参数，指定了vector中存储的元素的类型。uint64_t 是一个无符号整数类型，其大小至少为64位（即至少可以表示从0到2^64-1的整数）。这个类型通常定义在 <cstdint> 头文件中。
        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] + dp[i - 1][j - 1];
                else dp[i][j] = dp[i - 1][j];
            }
        }
        return dp[s.size()][t.size()];
    }
};