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

JAVA代码编写

392.判断子序列

给定字符串 st ,判断 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
  • 两个字符串都只由小写字符组成。

教程:https://programmercarl.com/0392.%E5%88%A4%E6%96%AD%E5%AD%90%E5%BA%8F%E5%88%97.html

方法一:动态规划

思路

五部曲

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

2.确定递归公式

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

  • 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];

3.数组初始化

初始化均为0

4.遍历顺序

同理从递推公式可以看出dp[i][j]都是依赖于dp[i - 1] [j - 1] 和 dp[i] [j - 1],那么遍历顺序也应该是从上到下,从左到右

5.举个例子

以示例一为例,输入:s = “abc”, t = “ahbgdc”,dp状态转移图如下:

代码随想录算法训练营第55天| 392.判断子序列 115.不同的子序列_第1张图片

复杂度分析

  • 时间复杂度:O(mn),其中m和n分别表示字符串s和字符串t的长度。
  • 空间复杂度:O(mn)
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 ? true: false;
    }
}

方法二:双指针法

思路:初始化两个指针i和j,分别指向s和t的起始位置。

然后,进入循环,循环条件是i小于s的长度且j小于t的长度。在每次循环中,比较s.charAt(i)和t.charAt(j)两个字符是否相等,如果相等,则说明s中的当前字符匹配到了t中的当前字符,此时将i向后移动一位,表示已经匹配成功一个字符。

无论是否匹配成功,都将j向后移动一位,继续比较下一个字符。

最后,循环结束后,判断i是否等于s的长度,如果相等,则说明s中的所有字符都成功匹配到了t的子序列中,返回true,否则返回false。

复杂度分析

  • 时间复杂度:O(min(s.length(), t.length())),其中s.length()和t.length()分别表示字符串s和字符串t的长度。
  • 空间复杂度:O(1)
class Solution {
    public boolean isSubsequence(String s, String t) {
        int i = 0, j = 0;
        while (i < s.length() && j < t.length()) {
            if (s.charAt(i) == t.charAt(j)) {
                i++;
            }
            j++;
        }
        return i == s.length();
    }
    public static void main(String[] args) {
        Solution solution = new Solution();
        System.out.println(solution.isSubsequence("abc","ahbgdc"));
    }
}

115.不同的子序列

给你两个字符串 st ,统计并返回在 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

提示:

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

教程:https://programmercarl.com/0115.%E4%B8%8D%E5%90%8C%E7%9A%84%E5%AD%90%E5%BA%8F%E5%88%97.html

方法一:动态规划

思路

五部曲

1.定义数组dp[i] [j]:以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。

2.确定递归公式

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

  • 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];

3.数组初始化

 for (int i = 0; i < s.length() + 1; i++) {
     dp[i][0] = 1;
 }

4.遍历顺序

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

5.举个例子

以s:“baegg”,t:"bag"为例,推导dp数组状态如下:

代码随想录算法训练营第55天| 392.判断子序列 115.不同的子序列_第2张图片

复杂度分析

  • 时间复杂度:O(mn)
  • 空间复杂度:O(mn)
class Solution {
    public int numDistinct(String s, String t) {
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        for (int i = 0; i < s.length() + 1; i++) {
            dp[i][0] = 1;
        }
        
        for (int i = 1; i < s.length() + 1; i++) {
            for (int j = 1; j < t.length() + 1; 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[s.length()][t.length()];
    }
}

你可能感兴趣的:(leetcode,代码随想录,算法,算法)