392.判断子序列，115.不同的子序列

392. 判断子序列

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

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

进阶：

如果有大量输入的 S，称作 S1, S2, ... , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？

致谢：

特别感谢 @pbrother 添加此问题并且创建所有测试用例。

示例 1：

输入：s = "abc", t = "ahbgdc"
输出：true

示例 2：

输入：s = "axc", t = "ahbgdc"
输出：false

提示：

• 0 <= s.length <= 100
• 0 <= t.length <= 10^4
• 两个字符串都只由小写字符组成。

 

首先肯定想到用双指针做：

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        int i = 0, j = 0; 
        while(i < m && j < n) {
            if (s.charAt(i) == t.charAt(j)) {
                i++;
            }
            j++;
        }
        return i == m;
    }
}

那么用动规怎么做呢？其实这是一个编辑距离问题。dp[i][j] 表示以下标 i-1 为结尾的字符串s，和以下标 j-1 为结尾的字符串t，相同子序列的长度为dp[i][j]。判断 dp[m][n] 的值是否和子串长度相等就可以了。

class Solution {
    public boolean isSubsequence(String s, String t) {
        int m = s.length();
        int n = t.length();
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                }
                else {
                    dp[i][j] = dp[i][j - 1];
                }
            }
        }
        return dp[m][n] == m;
    }
}

115. 不同的子序列

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

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

题目数据保证答案符合 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

提示：

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

 

这题很不好想。首先确定dp数组如何设定：dp[i][j] 是以下标为 i - 1 的元素为结尾的 s 的子序列中以下标为 j - 1 的元素为结尾的 t 的子序列出现的个数。本题要分析两种情况：元素 s[i - 1] 和 元素 t[j - 1] 相等、元素s[i - 1] 和 元素t[j - 1] 不相等。不相等的情况很好想，dp[i - 1][j] 对应的 s 的子序列（以下标为 i - 2 的元素为结尾的 s 的子序列）添加上一个s[i - 1]，因为没有对应的 t 的子序列的元素匹配，能匹配的 t 的子序列不会增加。相等的情况又要考虑 s[i - 1] 和 t[j - 1] 是否是匹配的情况。注意匹配不是相等。不匹配和不相等的情况是一样的，而匹配的情况，我们只要考虑 dp[i - 1][j - 1]是多少，因为其对应的以下标为 i - 2 的元素为结尾的 s 的子序列添加上 s[i - 1]，以下标为 j - 2 的元素为结尾的 t 的子序列添加上 t[j - 1]，不会改变匹配的情况，所以此种情况下 dp[i - 1][j - 1] == dp[i][j] 。相等的情况是匹配个数和不匹配个数相加。可以这样考虑，dp[i][j] 对应的 t 的子序列中，有匹配得上 s[i - 1] 的，有匹配不上的，不存在第三种情况，所以把这两种情况的个数相加，就是相等的所有情况了。

class Solution {
    public int numDistinct(String s, String t) {
        int m = s.length(), n = t.length();
        if (m < n)  return 0;
        int[][] dp = new int[m + 1][n + 1];
        for (int i = 0; i <= m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 1; i <= m; i++) {
            for (int j = 1; j <= n; j++) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }
                else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[m][n];
    }
}

压缩空间：

class Solution {
    public int numDistinct(String s, String t) {
        int m = s.length(), n = t.length();
        if (m < n)  return 0;
        int[] dp = new int[n + 1];
        dp[0] = 1;

        for (int i = 1; i < m; i++) {
            for (int j = n; j > 0; j--) {
                if (s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[j] = dp[j - 1] + dp[j];
                }
            }
        }
        return s.charAt(m - 1) == t.charAt(n - 1) ? dp[n] + dp[n - 1] : dp[n];
    }
}