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

文章目录

• • Leetcode 392.判断子序列
  • Leetcode 115.不同的子序列

Leetcode 392.判断子序列

题目链接：Leetcode 392.判断子序列
题目描述： 给定字符串 s 和 t ，判断 s 是否为 t 的子序列。字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。

思路： 由于本题只需要判断s是否是t的子序列，因此可以利用双指针来解决：两个指针i和j分别指向两个字符串的初始位置，如果这两个字符相等，则i和j同时移动到下一位；否则只有j移动到下一位，i不变，最后我们只需要判断i是否到达字符串的末尾即可。

代码如下：（双指针）

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.size(), m = t.size();
        int i = 0, j = 0;
        while (i < n && j < m) {
            if (s[i] == t[j]) { //只有匹配成功i才向后移动
                i++;
            }
            j++;
        }
        return i == n;//判断i是否到结尾
    }
};

• 时间复杂度：$O(n+m)$
• 空间复杂度：$O(1)$

本题也可以利用动态规划解决：

• 定义dp[i][j]：表示以下标i - 1为结尾的字符串s，和以下标j - 1为结尾的字符串t，相同子序列的长度为dp[i][j]（牢记这个定义，为了给初始化留出空间）
• 递推公式：如果s[i - 1] == t[j - 1]，说明此时序列相同，就在dp[i - 1][j - 1]基础上+ 1；否则等于dp[i][j - 1]，也就是不考虑t[j - 1]这个字母，延续之前考虑t[j - 2]得到的结果。
• 初始化：初始化为0
• 遍历顺序：从前向后，从上向下

代码如下：（动态规划）

class Solution {
public:
    bool isSubsequence(string s, string t) {
        int n = s.size(), m = t.size();
        //dp[i][j] 表示以下标i-1为结尾的字符串s，和以下标j-1为结尾的字符串t，相同子序列的长度
        vector<vector<int>> dp(n + 5, vector<int>(m + 5, 0));
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; 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[n][m] == n;
    }
};

• 时间复杂度：$O(n\times m)$
• 空间复杂度：$O(n\times m)$

Leetcode 115.不同的子序列

题目链接：Leetcode 115.不同的子序列
题目描述： 给你两个字符串 s 和 t ，统计并返回在 s 的子序列中 t 出现的个数，结果需要对 $10^9+7$ 取模。

思路： 本题与上道题不同的是：上道题仅仅判断即可，而本题需要统计个数。

• 定义dp[i][j]：表示以下标i - 1为结尾的字符串s，和以下标j - 1为结尾的字符串t，相同子序列的长度为dp[i][j]（注意是i - 1）
• 递推公式：两种情况，s[i - 1] 与 t[j - 1]相等或者不相等。无论是否相等，我们都需要记录所有子序列个数，因此递推dp[i][j]的过程中要加上之前的结果dp[i - 1][j]，也就是s[i - 2]与t[i - 1]比较的结果。 不过对于s[i - 1] 与 t[j - 1]相等的情况下，我们还需要加上s[i - 2]与t[i - 2]比较的结果。
• 初始化：dp[i][0] = 1，dp[0][j] = 0 ($i\in [0,s.size()]$ , $j\in [1,t.size()]$)
• 遍历顺序：从前向后，从上向下

代码如下：

class Solution {
public:
using ULL = unsigned long long;
    int numDistinct(string s, string t) {
        int n = s.size(), m = t.size();
        vector<vector<ULL>> dp(s.size() + 5,vector<ULL>(t.size() + 5));
        //初始化
        for(int i = 0; i <= n; i ++ ) dp[i][0] = 1;
        for(int j = 1; j <=m; j ++ ) dp[0][j] = 0;
        
        for(int i = 1; i <= n; i ++ )
            for(int j = 1; j <= m; 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[n][m];
    }
};

• 时间复杂度：$O(n\times m)$
• 空间复杂度：$O(n\times m)$

---

总结： 最后一道题的递推公式不太好理解，我感觉我并没有理解透彻。

最后，如果文章有错误，请在评论区或私信指出，让我们共同进步！

原文地址：https://blog.csdn.net/Camellia__Wang/article/details/136560493

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！