第五十四天| 392.判断子序列、115.不同的子序列

Leetcode 392.判断子序列

题目链接：392 判断子序列

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

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

思考：动态规划。此题和1143 最长公共子序列非常相似，用1143题的代码也能AC。按1143题的代码 逻辑上可以理解为寻找两个字符串的公共子序列长度，如果子序列长度不等于字符串s的长度则说明在字符串t中找不到与字符串s匹配的子序列，反则存在。

当然如果从题干理解，字符串s不能删除（即其中每个元素都必须考虑），因此当前两元素不相等时，递推公式应该为dp[i][j] = dp[i][j - 1];

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) {
        //dp[i][j]: 字符串s的处理区间[0, i - 1]与 字符串t的处理区间[0, j - 1]，其中的最长公共子序列长度
        vector<vector<int>> dp(s.size() + 1, vector<int>(t.size() + 1, 0));

        for (int i = 1; i <= s.size(); i++) {           //遍历字符串s
            for (int j = 1; j <= t.size(); j++) {       //遍历字符串t
                if (s[i - 1] == t[j - 1])
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                else
                    // dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);      //逻辑上 两字符串元素均可不考虑（删除）
                    dp[i][j] = dp[i][j - 1];        //逻辑上 仅字符串t元素可不考虑（删除）
            }
        }
        return dp[s.size()][t.size()] == s.size();
    }
};

思考：双指针法。慢指针指向模式串s中的字符，快指针指向主串t中的字符。当两指针指向的字符相同则两指针都往后移动，反正仅快指针移动。

如此处理直至快指针移动到主串t尾部之后 或 慢指针移动到模式串s尾部之后。最后若慢指针指向模式串s尾部则找到匹配的子序列，反则否之。

代码： 

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int slow = 0;       //慢指针 指向字符串s
        for (int fast = 0; fast < t.size() && slow < s.size(); fast++) {       //快指针 指向字符串t
            if (s[slow] == t[fast])
                slow++;     //慢指针和快指针指向字符匹配 则慢指针往后移
        }
        return slow == s.size();
    }
};

Leetcode 115.不同的子序列

题目链接：115 不同的子序列

题干：给你两个字符串 s 和 t ，统计并返回在 s 的 子序列 中 t 出现的个数，结果需要对 109 + 7 取模。

思考：动态规划。难点：理解将问题差分为不同处理区间的子序列个数。

• 确定dp数组（dp table）以及下标的含义

dp[i][j]：以下标i - 1结尾的主串s含以下标j - 1结尾的模式串t的子序列个数

为什么i-1，j-1 这么定义，在718. 最长重复子数组中讲过理由。

• 确定递推公式

遍历两字符串，将两字符串的每个字符都就行比较。因此要分析以下两种情况：

• s[i - 1] 与 t[j - 1]相等
• 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子串（除最后一位字母）和模式串t子串的子序列匹配情况。

所以当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]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]。所以递推公式为：dp[i][j] = dp[i - 1][j];

• dp数组如何初始化

从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j] 是从上方和左上方推导而来，因此 dp[i][0] 和dp[0][j]是一定要初始化的。

从定义来看，dp[i][0]相当于以下标i - 1结尾的主串s含空模式串t的子序列个数，默认为1。

dp[0][j]相当于以空主串s含以下标j - 1结尾的模式串t的子序列个数，肯定为0。

• 确定遍历顺序

从递推公式dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j]; 和 dp[i][j] = dp[i - 1][j]; 中可以看出dp[i][j]都是根据左上方和正上方推出来的。

• 举例推导dp数组

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

代码：

class Solution {
public:
    int numDistinct(string s, string t) {
        //dp[i][j]:以下标i - 1结尾的主串s含以下标j - 1结尾的模式串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++) {           //遍历主串s
            for (int j = 1; j <= t.size(); j++) {       //遍历模式串t
                if (s[i - 1] == t[j - 1])
                    //若当前两位置字符相同 则当前找到的匹配子序列 加上主串之前找到的匹配子序列 可赋值给当前dp[i][j]
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                else 
                    //若当前两位置字符不相同，则将主串之前找到的匹配子序列 赋值给当前dp[i][j]
                    dp[i][j] = dp[i - 1][j];
            }
        }
        return dp[s.size()][t.size()];
    }
};