⭐️392.判断子序列
文章链接:392.判断子序列
视频链接:动态规划,用相似思路解决复杂问题 | LeetCode:392.判断子序列
状态:其实本题如果使用双指针的话还是非常简单的,不过本题是编辑距离类题目的基础题,非常重要!所以用动态规划来进行解题
对于给定的字符串s
和t
,我们需要判断字符串s
是不是字符串t
的子序列,而且并不要求s
在t
中为连续。其实我们也可以理解成,字符串t
匹配s
,如果遇到不相同的元素,字符串t
就删除元素,如果t
能和s
完全相同,那么就返回true
其实本题可以使用双指针来解题,时间复杂度也是O(n)
,后续会给出答案。
那么为什么本题能够使用动态规划的方法呢?对于子序列问题就有最优子结构的性质。最优子结构意味着原问题的最优解可以由子问题的最优解推导出来。
思路
- dp数组下标以及含义
老一样:
dp[i][j]
表示以下标i-1
为结尾的字符串s
,和以下标j-1
为结尾的字符串t
,相同子序列的长度为dp[i][j]
。
这里设置成相同子序列长度,为了保证最后i
能够全部匹配上j
。如果s的长度为3,那么就必须保证对于某个j
而言dp[3][j]
为3
这里为什么要定义成下标i-1
为结尾和以下标j-1
为结尾呢?因为如果以i、j
结尾,会让初始化的写法非常麻烦。
- 确定递推公式
递推公式主要有两种操作:
-
if (s[i - 1] == t[j - 1])
- t中找到了一个字符在s中也出现了。找到了一个相同的字符,相同子序列长度自然要在
dp[i-1][j-1]
的基础上加1
- t中找到了一个字符在s中也出现了。找到了一个相同的字符,相同子序列长度自然要在
-
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]
;
- 相当于t要删除元素,继续匹配。
if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = dp[i][j - 1];
- 初始化
从递推公式可以看出,我们dp[i][j]
都是依赖于dp[i - 1][j - 1]
和 dp[i][j-1]
,也就是说,我们的当前格子需要左上方格子和左边格子才能推导出来。
![](https://img-blog.csdnimg.cn/direct/f880d4dac399438f821f44b1c44f41df.png#pic_center)
通过本图片,我们也可以看出为什么要表示以下标i-1为结尾的字符串s,和以下标j-1为结尾的字符串t,相同子序列的长度为dp[i][j]
。就是为了在二维句珍重可以留出初始化空间。
- 确定遍历顺序
根据递推公式来的,从上到下,从左到右
- 举例推导dp数组
以示例一为例,输入:s = “abc”, t = “ahbgdc”,dp状态转移图如下:
![](https://img-blog.csdnimg.cn/direct/ba475235bb3448738ac0f98ec8ff7102.jpeg#pic_center)
CPP代码
class Solution {
public:
bool isSubsequence(string s, string t) {
int s_len = s.size();
int t_len = t.size();
vector<vector<int>> dp(s_len + 1, vector<int>(t_len + 1, 0));
for (int i = 1; i <= s_len; i++) {
for (int j = 1; j <= t_len; j++) {
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[s_len][t_len] == s_len ? true : false;
}
};
双指针
- 初始化两个指针 i 和 j,分别指向字符串 s 和 t 的起始位置。
- 遍历字符串 t,对于每个字符 t[j]:
- 如果 s[i] == t[j],则移动指针 i,指向 s 的下一个字符。
- 不论是否匹配,指针 j 都向前移动,指向 t 的下一个字符。
- 遍历完成后,如果 i 达到了 s 的末尾(即 i == s.length()),则说明 s 是 t 的子序列。
class Solution {
public:
bool isSubsequence(string s, string t) {
if (s.empty()) return true;
int i = 0, j = 0;
while (j < t.size()) {
if (s[i] == t[j] && i < s.size()) {
i++;
}
j++;
}
return i == s.size();
}
};
扩展题
如果有大量输入的 S,称作 S1, S2, … , Sk 其中 k >= 10亿,你需要依次检查它们是否为 T 的子序列。在这种情况下,你会怎样改变代码?
原算法的问题
原算法对于每个 S 都需要遍历一次 T。假设 S 的平均长度为 m,T 的长度为 n,那么对于每个 S,时间复杂度为 O(n + m),遍历 k 个 S 的总时间复杂度为 O(k * (n + m))。当 k 非常大时(如 10亿),这种方法会非常耗时且不可行。
预处理T的方法
-
预处理函数 (preprocess):
- 为字符串 t 创建一个预处理表 next, 其中 next[i][c] 指示字符 c 从位置 i 向后搜索在 t 中第一次出现的位置。
- 如果 c 在位置 i 后不存在于 t 中,next[i][c] 将被设置为 t 的长度(表示不存在)。
-
子序列检测函数 (isSubsequence):
- 检查是否每个字符 c 在字符串 s 中都按顺序在 t 中出现。
- 使用 next 数组快速跳过 t 中的不需要的字符,实现快速查找。
- 如果 s 中的任何字符在 t 中不存在,或 t 被完全遍历而未找到 s 的某些字符,则返回 false。
- 如果遍历完 s 所有字符并正确匹配,返回 true。
代码实现
class Solution {
public:
vector<vector<int>> preprocess(const string& t) {
int n = t.size();
vector<vector<int>> next(n + 1, vector<int>(256, n));
for (int i = n - 1; i >= 0; --i) {
for (int c = 0; c < 256; ++c) {
next[i][c] = next[i + 1][c];
}
next[i][t[i]] = i;
}
return next;
}
bool isSubsequence(string s, string t) {
if (s.empty()) return true;
if (t.empty()) return false;
vector<vector<int>> next = preprocess(t);
int index = 0; // Current index in t
for (char c : s) {
if (index == t.size()) return false; // Reached end of t, no match found
if (next[index][c] == t.size()) return false; // Character c is not found in the rest of t
index = next[index][c] + 1; // Move to the next character in t after the found character
}
return true;
}
};
复杂度分析
- 预处理时间复杂度:
O(m)
,其中 m 是 T 的长度。构建位置索引需要遍历一次 T 。 - 查询时间复杂度:
O(m *256 + n)
,256是字符集的长度,我们其实可以直接忽略掉;n是 S 的长度。- 如果是计算 k 个平均长度为 n 的字符串 S 是否为 T 的子序列,则时间复杂度为 O ( m × 256 + k × n ) O(m \times256 + k\times n) O(m×256+k×n)
- 如果我们使用双指针的方法,对于k个字符串的话是 O ( k × ( m + n ) ) O(k\times(m+n)) O(k×(m+n))
- 空间复杂度:
O(m)
,存储T
中每个字符的位置列表
这种方法通过预处理 T,在查询时大幅提升了性能,适合处理大量输入的 S。
115.不同的子序列
视频讲解:动态规划之子序列,为了编辑距离做铺垫 | LeetCode:115.不同的子序列
文章讲解:115.不同的子序列
KMP算法求的是连续序列,本题中仅仅是来求子序列(字符串的一个 子序列 是指,通过删除一些(也可以不删除)字符且不干扰剩余字符相对位置所组成的新字符串。)
思路
- 确定dp数组下标以及含义
dp[i][j]
:以i-1
为结尾的s
子序列中出现以j-1
为结尾的t
的个数为dp[i][j]
。
- 确定递推公式
这一类问题,基本是要分析两种情况,这里是跟上一题一样的
- s[i - 1] 与 t[j - 1]相等
当s[i - 1] 与 t[j - 1]相等时,dp[i][j]
可以有两部分组成。
一种是使用s[j-1]
来匹配字符串,另一种是不使用s[j - 1]
来匹配字符串(因为s
中可能有多个字符能与t[j - 1]
)匹配。
所以我们的递推公式
if (s[i - 1] == t[j - 1]){
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];//分别对应用s[j-1]匹配和不用s[j-1]匹配
}
- 使用
s[i - 1]
来匹配t[j - 1]
,此时s
的前i
个字符匹配t
的前j
个字符,可以看作是在s
的前i - 1
个字符匹配t
的前j - 1
个字符的基础上,将s[i - 1]
与t[j - 1]
匹配起来。因此,此时dp[i][j]
应该等于dp[i - 1][j - 1]
。- 不使用
s[i - 1]
来匹配t[j - 1]
,而是保持s
的前i - 1
个字符匹配t
的前j
个字符,即s
的前i
个字符在t
的前j
个字符中的匹配方式不依赖于s[i - 1]
,而是与s[i - 2]
以及t[j - 1]
的匹配方式相关。因此,此时dp[i][j]
应该等于dp[i - 1][j]
。- 并且要注意的是这里的结果是相加的!相加就是在累积所有方法
- s[i - 1] 与 t[j - 1] 不相等
当s[i - 1]
与 t[j - 1]
不相等时,dp[i][j]
只有一部分组成,不用s[i - 1]
来匹配(就是模拟在s中删除这个元素),此时的状态还是依赖于s[i-1]
的前一个元素即:dp[i - 1][j]
- dp数组的初始化
还是从递推公式来的,所以我们必须初始化dp[i][0]
和dp[0][j]
![](https://img-blog.csdnimg.cn/direct/4cf0c53bacbc45b5ba4f8edd1043ce62.png#pic_center)
从递推公式的定义出发,
那么dp[i][0]
一定都是1,因为也就是把以i-1为结尾的s,删除所有元素,出现空字符串的个数就是1。
那么dp[0
][j]一定都是0,s
如论如何也变成不了t
。
dp[0][0]
呢?那必然是1,因为空字符串s可以删除0个元素,变成空字符串t
vector<vector<long long>> dp(s.size() + 1, vector<long long>(t.size() + 1));
for (int i = 0; i <= s.size(); i++) dp[i][0] = 1;
for (int j = 1; j <= t.size(); j++) dp[0][j] = 0;
- 确定遍历顺序
关于遍历顺序从上图也能看出,总左到右,从上到下
- 打印dp数组
![](https://img-blog.csdnimg.cn/direct/5fd4f7f665d6491e81ac1d9495b3d0e6.jpeg#pic_center)
CPP代码
class Solution {
public:
int numDistinct(string s, string t) {
int s_len = s.size();
int t_len = t.size();
vector<vector<unsigned long long>> dp(s_len + 1, vector<unsigned long long>(t_len + 1, 0));
for (int i = 0; i <= s_len; i++) dp[i][0] = 1;
for (int j = 1; j <= t_len; j++) dp[0][j] = 0;
for (int i = 1; i <= s_len; i++) {
for (int j = 1; j <= t_len; j++) {
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[s_len][t_len];
}
};