代码随想录算法训练营DAY52|C++动态规划Part13|392.判断子序列、115.不同的子序列

⭐️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结尾，会让初始化的写法非常麻烦。

• 确定递推公式

递推公式主要有两种操作：

1. if (s[i - 1] == t[j - 1])

   • t中找到了一个字符在s中也出现了。找到了一个相同的字符，相同子序列长度自然要在dp[i-1][j-1]的基础上加1

2. 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];

if (s[i - 1] == t[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1;
else dp[i][j] = dp[i][j - 1];
1
2

• 初始化

从递推公式可以看出，我们dp[i][j]都是依赖于dp[i - 1][j - 1] 和 dp[i][j-1]，也就是说，我们的当前格子需要左上方格子和左边格子才能推导出来。

通过本图片，我们也可以看出为什么要表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度为dp[i][j]。就是为了在二维句珍重可以留出初始化空间。

• 确定遍历顺序

根据递推公式来的，从上到下，从左到右

• 举例推导dp数组

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

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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

双指针

1. 初始化两个指针 i 和 j，分别指向字符串 s 和 t 的起始位置。
2. 遍历字符串 t，对于每个字符 t[j]：
   • 如果 s[i] == t[j]，则移动指针 i，指向 s 的下一个字符。
   • 不论是否匹配，指针 j 都向前移动，指向 t 的下一个字符。
3. 遍历完成后，如果 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();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

扩展题

如果有大量输入的 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的方法

1. 预处理函数 (preprocess):

   • 为字符串 t 创建一个预处理表 next, 其中 next[i][c] 指示字符 c 从位置 i 向后搜索在 t 中第一次出现的位置。
   • 如果 c 在位置 i 后不存在于 t 中，next[i][c] 将被设置为 t 的长度（表示不存在）。

2. 子序列检测函数 (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;
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

复杂度分析

• 预处理时间复杂度：O(m)，其中 m 是 T 的长度。构建位置索引需要遍历一次 T 。
• 查询时间复杂度：O(m *256 + n)，256是字符集的长度，我们其实可以直接忽略掉；n是 S 的长度。
  • 如果是计算 k 个平均长度为 n 的字符串 S 是否为 T 的子序列，则时间复杂度为$O(m\times 256+k\times n)$
  • 如果我们使用双指针的方法，对于k个字符串的话是$O(k\times (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]。

• 确定递推公式

这一类问题，基本是要分析两种情况，这里是跟上一题一样的

1. 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]匹配
}
1
2
3

• 使用 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]。
• 并且要注意的是这里的结果是相加的！相加就是在累积所有方法

2. 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]

从递推公式的定义出发，

那么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; 
1
2
3

• 确定遍历顺序

关于遍历顺序从上图也能看出，总左到右，从上到下

• 打印dp数组

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];
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18