代码随想录算法训练营第四期第五十五天 | 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
# 两个字符串都只由小写字符组成。

1.确定dp数组（dp table）以及下标的含义
dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。

2.确定递推公式
if (s[i - 1] == t[j - 1])，那么dp[i][j] = dp[i - 1][j - 1] + 1;，
if (s[i - 1] != t[j - 1])，即：dp[i][j] = dp[i][j - 1];

3.初始化
dp = [[0 for _ in range(len(t) + 1)] for _ in range(len(s) + 1)]
注意，这里一定要先遍历长为行，再构建短的为列，然后for循环，短匹配长，看是否相等

4.确定遍历顺序
从上到下，从左到右

5.打印dp数组
这里以s = "abc", t = "ahbgdc"为例子
    t   a   h   b   g   d   c
s   0   0   0   0   0   0   0   ——初始化为0
a   0 ->1 ->1 ->1 ->1 ->1 ->1
b   0 ->0 ->0 \>2 ->2 ->2 ->2   ——当对应字母相等的时候，取dp[i - 1][j - 1] + 1
c   0 ->0 ->0 ->0 ->0 ->0 \>3   ——当对应字母不等的时候，就延续左边的值
    |
初始化为0

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        dp = [[0 for _ in range(len(t) + 1)] for _ in range(len(s) + 1)]
        for i in range(1, len(s) + 1):
            for j in range(1, len(t) + 1):
                if s[i - 1] == t[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = dp[i][j - 1]
        return dp[-1][-1] == len(s)

    # 看了随想录上双指针三个字，琢磨了一下，写出来了
    def isSubsequence1(self, s: str, t: str) -> bool:
        first = 0
        second = 0
        while True:
            if first == len(s):
                return True
            if second == len(t):
                return False
            if s[first] == t[second]:
                first += 1
            second += 1

    # 自己想的用切片的方法写的，没想到对的
    def isSubsequence2(self, s: str, t: str) -> bool:
        if len(s) == 0:
            return True
        # 下面可以注释
        # if len(t) == 0:
        #     return False
        i = 0
        while True:
            if s[i] not in t:
                return False
            else:
                index = t.index(s[i])
                if i == len(s) - 1:
                    return True
                t = t[index + 1:]
                i += 1


if __name__ == '__main__':
    s = "abc"
    # s = "axc"
    t = "ahbgdc"
    tmp = Solution()
    res = tmp.isSubsequence(s, t)
    print(res)

115.不同的子序列

# 给定一个字符串 s 和一个字符串 t ，计算在 s 的子序列中 t 出现的个数。
# 字符串的一个 子序列 是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，"ACE" 是 "ABCDE" 的一个子序列，
# 而 "AEC" 不是）
# 题目数据保证答案符合 32 位带符号整数范围。
#
# 示例1：
# 输入：s = "rabbbit", t = "rabbit"
# 输出：3
# 解释：
# 如下图所示, 有 3 种可以从 s 中得到 "rabbit" 的方案。
# rabbbit （取rabb和it）
# rabbbit （取ra和bbit）
# rabbbit （取rab和bit）
#
# 示例2：
# 输入：s = "babgbag", t = "bag"
# 输出：5
# 解释：
# 如下图所示, 有 5 种可以从 s 中得到 "bag" 的方案。
# babgbag（取ba和前面的g）
# babgbag（取ba和后面的g）
# babgbag（取第一个b和后面的ag）
# babgbag（取第二个b和后面的ag）
# babgbag（取最后三个字母bag）
#
# 提示：
# 0 <= s.length, t.length <= 1000
# s 和 t 由英文字母组成

class Solution:
    # 看了视频和讲解，完全没懂，先抄下
    def numDistinct(self, s: str, t: str) -> int:
        # dp = [[0] * (len(t)+1) for _ in range(len(s)+1)]
        # for i in range(len(s)):
        #     dp[i][0] = 1
        # for j in range(1, len(t)):
        #     dp[0][j] = 0
        # for i in range(1, len(s)+1):
        #     for j in range(1, len(t)+1):
        #         if s[i-1] == t[j-1]:
        #             dp[i][j] = dp[i-1][j-1] + dp[i-1][j]
        #         else:
        #             dp[i][j] = dp[i-1][j]
        # return dp[-1][-1]