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

LeetCode 392. 判断子序列

链接：392. 判断子序列

双指针：

思路：

本题较容易，如果不用动态规划而是用双指针的办法思路会更加简单。首先两个指针fast，slow分别代表t，s的下标，快指针用于遍历长字符串t，慢指针遍历短字符串s。在遍历字符串之前可以先做一个判断，如果s长于t，则无论如何都无法在t中找到子序列s，直接返回false，如果s长度为0，则直接返回true。

然后是遍历的过程，快指针每次走一步，慢指针在当s[slow]等于t[fast]的时候才走一步，直到慢指针走完，则说明t存在子序列s，否则说明不存在。

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) {
        if (t.size() < s.size())
           return false;
       int slow = 0, fast = 0;
        if (slow == s.size())
              return true;
        for (int fast = 0; fast < t.size();fast++)
        {
          if (t[fast] == s[slow])
          slow++;
          if (slow == s.size())
              return true;
}
        return false;
    }
};

动态规划：

思路：

相比于双指针，动态规划的思路要稍复杂些，但是仔细观察可以发现，本题和1143. 最长公共子序列思路十分相似，如果s和t的最长公共子串为s，则说明s一定是t的子串，照着这个思路，我们可以把最长公共子序列的代码直接照搬过来，最后加一个判断，如果dp[s.size()][t.size()] != s.size()，则说明s和t的最长公共子串不是s，s不为t的子序列，反之亦然。

另外在递推公式有一点需要注意，虽然不影响结果，但其实当s[i-1]不等于t[j-1]的时候，dp[i][j]不应该由dp[i-1][j]和dp[i][j-1]的最大值来决定，实际上dp[i][j]只可能来自dp[i][j-1]，原因是当字符不匹配的时候我们不能跳过s的字符，而只能跳过t的字符，因为我们需要找到全部能匹配s的字符的t的子串，一旦跳过了会影响到dp的数值，但好在不影响本题的结果，只要我们最后做了dp数值是否等于s的长度的判断就不会出错。

代码：

class Solution {
public:
    bool isSubsequence(string s, string t) {
        // dp[i][j]表示长度为[0, i]的s和[0, j]的t的最长公共子序列长度
        vectorint>> dp(s.size() + 1, vector<int>(t.size() + 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] + 1;
                else
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        if (dp[s.size()][t.size()] != s.size())
            return false;
        else
            return true;
    }
};

LeetCode 115. 不同的子序列

链接：115. 不同的子序列

思路：

这道题目难度一下子就上来了，我们还是按照动态规划的思路来解。首先定义下标：dp[i][j]表示字符串s中长度为i的子序列出现字符串t中长度为j的子序列的次数。根据定义，我们可以知道，当j为0时，不论s的长度为多少，出现长度为0的子序列的次数都为1，因为此时唯一的方法就是删除s中所有的字符，当然也包括s长度为0的情况，这时就不用删除。所以初始dp数组为dp[i][0] = 1,i的范围取[0, s.size()]。dp数组其余数均初始化为0。

接下来关键的地方是递推公式，当匹配字符的时候，有s[i-1]等于t[j-1]和不等于t[j-1]两种情况，先考虑简单一点的情况。

1. s[i-1] != t[j-1]。这种时候的递推公式其实和上一题是一样的，当不相等的时候，跳过当前不匹配的s的字符串 ，令dp[i][j]等于去掉当前字符的上一个s的子字符串的长度i-1，也就是dp[i][j] = dp[i-1][j]。同样我们不能取dp[i][j-1]，理由在上一题已经说过了，匹配的字符串t必须是完整的不能跳过。
2. s[i-1] == t[j-1]。这种情况就相对复杂一些，首先当当前字符相等的时候，我们肯定可以匹配到当前字符，所以用s[i-1]去匹配t[j-1]时的方法数量为dp[i-1][j-1]，但同时我们也可以不选取当前字符去匹配，而尝试用s[i]去匹配t[j-1]，考虑这样一个例子：s = "abb", t = "ab"，当我们匹配到第二个字符，也就是i和j等于2的时候，我们可以用s[1]，也就是s的第一个"b"，去匹配t[1]，也可以用s[2]，也就是s的第二个“b"，去匹配t[1]，这样一来就有两种结果数量了，前者的结果数量为dp[i-1][j]，后者的结果数量为dp[i-1][j-1]，那么最终递推公式为dp[i][j] = dp[i-1][j-1] + dp[i-1][j]。

为了方便理解，这里再贴一张dp数组的推导过程，图来自代码随想录

最后，选取最靠右下角的数 dp[s.size()][t.size()]返回即可。

代码：

class Solution {
public:
    int numDistinct(string s, string t) {
        // dp[i][j]表示以i-1下标结尾的s的子序列出现以j-1下标结尾的t的子字符串的次数
        vectoruint64_t>> dp(s.size() + 1, vector<uint64_t>(t.size() + 1));
        // 初始化，当j为0时dp[i][0]为1
        for (int i = 0; i <= s.size(); i++)
            dp[i][0] = 1;
        for (int j = 1; j <= t.size(); j++)
            for (int i = 1; i <= s.size(); i++)
            {
                if (s[i-1] != t[j-1])
                    // 需要用t去匹配，所以j不能动
                    dp[i][j] = dp[i-1][j];
                else
                {
                    // 既可以用s[i-1]去匹配，也可以用s[i]去匹配
                    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                }
            }
            return dp[s.size()][t.size()];
    }
};