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()];
    }
};