LeetCode 392. 判断子序列 | Python

392. 判断子序列


题目来源:https://leetcode-cn.com/problems/is-subsequence/

题目


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

你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长(长度 ~= 500,000),而 s 是个短字符串(长度 <=100)。

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

示例 1:

s = "abc", t = "ahbgdc"

返回 true.

示例 2:

s = "axc", t = "ahbgdc"

返回 false.

后续挑战 :

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

解题思路


思路:双指针、动态规划

在这里,先理清题目所提出的问题,题目要问的是,s 是否是 t 的子序列?而题目中定义这个子序列,是指不改变相对位置在原字符串中删除一些(或者不删除)字符剩余的字符。

那么也就是说,只要能找到 s 在 t 中存在(相对位置顺序对应),那么可以认定 s 是 t 的子序列。例如,题目中所给出的示例,"ace" 是 "abcde" 的一个子序列,而 "aec" 不是。因为 "aec" 改变了相对位置的顺序。

在这里,我们可以从前往后匹配,而且可贪心地靠前匹配出现的字符。

当我们从前往后匹配字符的时候,假设出现的字符 x 在 t 中出现的位置,一个在前面,一个在后面。在这里,应该考虑匹配 x 在 t 出现前面的字符,这是因为往后匹配,当选定前面位置出现的字符时,能够更大概率匹配成功。(因为字符 x 出现在后面位置往后能取的字符,前面位置往后也能够取到,而且前后两个位置之前的字符也有可选字符。)

那么具体的算法如下:

  • 定义双指针 p、q,分别指向 s 和 t 的初始位置;
  • 这里匹配前面位置出现的字符(也就是进行贪心匹配),当匹配成功之后,指针同时往后移动;
  • 如果匹配失败,p 保持不同,移动 q。
  • 如果 p 能够到达末尾,那么说明 s 就是 t 的子序列。

具体的代码见【代码实现 # 双指针】

还有一个后续挑战,需要检验大量的 s 是否是 t 的子序列。在上面的双指针的方法当中,从前往后去匹配字符需要大量的时间,那么这里再使用双指针的方法显然不合适。

这里参考官方题解,说一下动态规划如何去快速匹配 s 是否是 t 的子序列。

首先用动态规划的方法去进行预处理,能够确定在 t 的每个位置,从该位置往后每个字符第一次出现的位置。

状态定义

设 dp[i][j] 表示字符串 t 中从 i 的位置开始往后匹配,j 第一次出现的位置。

状态转移方程

  • 如果 t 中位置 i 的字符就是 j 的话,那么 dp[i][j] = i;
  • 若不是上面的情况,那么也就是说 j 出现在 i 位置之后的某个位置(这里不包含 i),此时 dp[i][j] = dp[i+1][j]

状态初始化

在这里,索引从 0 开始,那么 i 的取值范围为 [0, t_len),这里不包含 t_len。那么,这里存在边界问题,当 i = t_len-1 的时候,这里可能会无法进行转移。我们让 i = t_len 的时候,令 dp[t_len][...] 为 t_len,那么也就说,当 dp[i][j] = t_len 的时候,那么就表示从 i 开始无法匹配 j。

具体的代码见【代码实现 # 动态规划】

代码实现


# 双指针
class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        s_len = len(s)
        t_len = len(t)

        # 定义双指针,指向 s 和 t 的初始位置
        p = 0
        q = 0

        while p < s_len and q < t_len:
            # 当 s 的字符与 t 的字符匹配时
            # 同时移动 p 和 q 指针
            if s[p] == t[q]:
                p += 1
            # 如果不匹配,只移动 q 指针,与 p 指针所对应的字符继续匹配判断
            q += 1
        # 如果 p 指针到达 s 末尾返回 True
        return p == s_len

# 动态规划
class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        s_len = len(s)
        t_len = len(t)

        dp = [[0] * 26 for _ in range(t_len)]
        # 这里是为了能够让 i = t_len-1 的时候能够正常转移
        dp.append([t_len]*26)

        # 在这里,从后往前枚举,因为 dp[i][j] 可能从 dp[i+1][j] 中转移而来
        for i in range(t_len-1, -1, -1):
            for j in range(26):
                # 如果位置 i 的字符就是 j 时,那么 dp[i][j] = i
                if ord(t[i]) == j + ord('a'):
                    dp[i][j] = i
                else:
                    dp[i][j] = dp[i+1][j]
                # dp[i][j] = i if ord(t[i]) == j + ord('a') else dp[i+1][j]
        
        # 开始遍历匹配 s,检验 s 的每个字符在 t 中的某个位置是否存在
        idx = 0
        for i in range(s_len):
            # 如果转移只有结果为 t_len,表示无法匹配字符,那么返回 False
            if dp[idx][ord(s[i]) - ord('a')] == t_len:
                return False
            # 当找到匹配当前字符的位置之后,从这个位置的下一个位置开始查找下一个字符是否出现在 t 中的某个位置
            idx = dp[idx][ord(s[i]) - ord('a')] + 1

        return True

实现结果


双指针

实现结果 | 双指针

动态规划

实现结果 | 动态规划

欢迎关注


公众号 【书所集录】

你可能感兴趣的:(LeetCode 392. 判断子序列 | Python)