代码随想录day55 | 动态规划P15 | ● 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

思路

双指针

只需要验证s中元素是否在t中出现,且存在相对顺序即可, 从左往右遍历t来实现相对顺序

动态规划

定义 dp[i][j]表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度

递推:

在确定递推公式的时候，首先要考虑如下两种操作，整理如下：

• if (s[i - 1] == t[j - 1])
  • t中找到了一个字符在s中也出现了
• if (s[i - 1] != t[j - 1])
  • 相当于t要删除元素，继续匹配

if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，因为找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1（如果不理解，在回看一下dp[i][j]的定义）

if (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];

其实这里 大家可以发现和 lc1143. 最长公共子序列的递推公式基本那就是一样的，区别就是 本题 如果删元素一定是字符串t，而 1143.最长公共子序列 是两个字符串都可以删元素。

代码

双指针

class Solution {
    public boolean isSubsequence(String s, String t) {
        if(s.length() == 0) return true;
        else if(t.length() == 0) return false;
        else{
            //长度均非0
            int i = 0, j = 0;
            for(;j < t.length(); j++){
                if(s.charAt(i) == t.charAt(j)){
                    i++;
                    if(i == s.length()) return true;
                }
            }
            return false;
        }
    }
}

动态规划

class Solution {
    public boolean isSubsequence(String s, String t) {
        if(s.length() == 0) return true;
        else if(t.length() == 0) return false;
        else{
            //长度均非0
            // dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。
            int [][] dp = new int[s.length()+1][t.length()+1];

            for(int i = 1; i <= s.length(); i++){
                for(int j = 1; j <= t.length(); 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[s.length()][t.length()] == s.length();
        }
    }
}

115.不同的子序列  

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

示例 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[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

递推

这一类问题，基本是要分析两种情况

• 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[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[i][0]表示什么呢？

dp[i][0] 表示：以i-1为结尾的s可以随便删除元素，出现空字符串的个数。

        那么dp[i][0]一定都是1，因为也就是把以i-1为结尾的s，删除所有元素，出现空字符串的个数就是1。

再来看dp[0][j]，dp[0][j]：空字符串s可以随便删除元素，出现以j-1为结尾的字符串t的个数。

        那么dp[0][j]一定都是0，s如论如何也变成不了t。

最后就要看一个特殊位置了，即：dp[0][0] 应该是多少。

        dp[0][0]应该是1，空字符串s，可以删除0个元素，变成空字符串t。

代码 

class Solution {
    public int numDistinct(String s, String t) {
        if(s.length() < t.length()) return 0;
        else if(s.length() == t.length()){
            if(s.equals(t)) return 1;
            return 0;
        }
        else{
            // dp[i][j] 表示 以i-1结尾的s串 的子序列中 出现以 j-1 结尾的t串的个数
            int [][] dp = new int [s.length()+1][t.length()+1];
            //初始化
            //首行
            for(int i=0; i<=s.length(); i++){
                dp[i][0] = 1;
            }
            //首列
            for(int i=0; i<=t.length(); i++){
                dp[0][i] = 0;
            }
            //dp[0][0]
            dp[0][0] = 1;

            for(int i = 1; i <= s.length(); i++){
                for(int j = 1; j <= t.length(); j++){
                    if(s.charAt(i-1) == t.charAt(j-1)){
                        //个数中 一部分是用s\i-1匹配 一部分不用 模拟在s中删掉s\i-1
                        dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                    }else{
                        //不同 只能不用
                        dp[i][j] = dp[i-1][j];
                    }
                }
            }
            int res =(int) Math.pow(10,9) + 7;
            return dp[s.length()][t.length()] % (res);
        }
    }
}