Day54｜动态规划part15：392.判断子序列、115.不同的子序列
392.判断子序列
leetcode链接：力扣题目链接
视频链接：动态规划之子序列，为了编辑距离做铺垫 | LeetCode：115.不同的子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）
字符而不改变剩余字符相对位置形成的新字符串。
（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
示例 1：
输入：s = "abc", t = "ahbgdc"
输出：true
示例 2：
输入：s = "axc", t = "ahbgdc"
输出：false
进阶：
如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，
你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
这题是作为编辑距离的铺垫。 这题可以看成：对于字符串t能不能通过有限的删除次数（只能删除）得到字符串s。
双指针法
本题比较简单，可用双指针法，外层循环遍历大串t，内层设置指针j遍历小串s。如果两者相等j往后移一位，如果最后j遍历完了，那么说明是true。如果t遍历完s还没有遍历完，说明是false。
最终代码：
class Solution {
public:
bool isSubsequence(string s, string t) {
if(s.size() > t.size() ){
return false;
}
if(s.size() == 0){
return true;
}
int j = 0;
for(int i = 0; i < t.size(); i++){//t是大串，s是小串
if(t[i] == s[j]){
j++;
if(j == s.size()){
return true;
}
}
}
return false;
}
};
动态规划
- 确定dp数组下标及其含义
dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
- 确定递推公式
如果dp[i - 1]和dp[j -1]相等，那么dp[i][j] = dp[i - 1][j - 1] + 1；
如果不相等，(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];
- dp数组的初始化
从递推公式可以看出dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j - 1]，所以dp[0][0]和dp[i][0]是一定要初始化的。
这里大家已经可以发现，在定义dp[i][j]含义的时候为什么要表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
因为这样的定义在dp二维矩阵中可以留出初始化的区间，如图：
dp[i][0] 表示以下标i-1为结尾的字符串，与空字符串的相同子序列长度，所以为0. dp[0][j]同理。
最后全部初始化为0即可。
- 遍历顺序
一定是从上到下从左往右的。
- 循环打印dp数组
转化结果：最终的个数 == s.size()说明都包涵
最终代码：
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];
}
}
}
return dp[s.size()][t.size()] == s.size();
}
};
- 时间复杂度：O(n × m)
- 空间复杂度：O(n × m)
115.不同的子序列
leetcode链接：力扣题目链接
视频链接：动态规划之子序列，为了编辑距离做铺垫 | LeetCode：115.不同的子序列
给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数。
题目数据保证答案符合 32 位带符号整数范围。
示例 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
注意这题和上一题的区别。这题不仅要判断是否含有子串，还要判断出现的个数。
- 确定dp数组下标及其含义
dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的子序列个数为dp[i][j]。
- 确定递推公式
无非就是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]。
即dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
- 如果不相等，只能不用s[i - 1]匹配，个数
dp[i][j] = dp[i - 1][j]
- 确定dp数组的初始化
dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。
那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。
dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。
那么dp[0][j]一定都是0，s如论如何也变成不了t。
dp[0][0] = 1，空字符串s，可以删除0个元素，变成空字符串t
- 确定遍历顺序
从上到下，从左到右
- 循环打印dp数组
最终代码：
class Solution {
public:
int numDistinct(string s, string t) {
vector<vector<uint64_t>> dp(s.size() + 1, vector<uint64_t> (t.size() + 1));
for (int i = 0; i < s.size(); i++) {
dp[i][0] = 1;
}
for (int j = 1; j < t.size(); j++) {
dp[0][j] = 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] + dp[i - 1][j];
}else{
dp[i][j] = dp[i - 1][j];
}
}
}
if(dp[s.size()][t.size()] >= INT32_MAX){
return -1;
}
return dp[s.size()][t.size()];
}
};
这里注意最后答案可以溢出，用uint64。另外最后的比较是一个特殊情况，溢出返回-1。
总结
- 子序列问题，实际上可以看成删除大串什么时候可与子串平齐。因此当两个串不相等的时候，比较哪个下标要弄清楚。
- 复杂问题的初始化，一定不能想当然，要慢慢分析下标的含义。