[leetcode] 115. Distinct Subsequences

最新推荐文章于 2024-02-14 11:24:21 发布

Peng_maple

最新推荐文章于 2024-02-14 11:24:21 发布

阅读量159

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 200 Dynamic Programming

本文链接：https://blog.youkuaiyun.com/Peng_maple/article/details/99054810

leetcode 200 同时被 2 个专栏收录

41 篇文章

订阅专栏

Dynamic Programming

15 篇文章

订阅专栏

本文详细解析了如何使用动态规划解决子序列计数问题，通过两个示例展示了具体的应用过程，包括初始化动态规划数组，递推公式推导，以及最终结果的计算。

Distinct Subsequences

Given a string S and a string T, count the number of distinct subsequences of S which equals T.

A subsequence of a string is a new string which is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (ie, “ACE” is a subsequence of “ABCDE” while “AEC” is not).

Example 1:

Input: S = “rabbbit”, T = “rabbit”
Output: 3
Explanation:
As shown below, there are 3 ways you can generate “rabbit” from S.
(The caret symbol ^ means the chosen letters)
rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^

Example 2:

Input: S = “babgbag”, T = “bag”
Output: 5
Explanation:
As shown below, there are 5 ways you can generate “bag” from S.
(The caret symbol ^ means the chosen letters)
babgbag
^^ ^
babgbag
^^ ^
babgbag
^ ^^
babgbag
^ ^^
babgbag
^^^

解析

找到字符串s中子串t的个数。

自己的解法

设一个二维数组dp[t.len][s.len]，dp[i][j]表示字符串s[0,j]有子串t[0,i]的个数，只有s[j]==t[i]时，才会>0；
当匹配到t的第i+1个字符时，当前与t[i+1]相同的字符位置s[j]的dp[i+1][j]是上一个匹配字符的个数之和，即dp[i+1][j] = dp[i][k] k<j；
最后结果为t的最后一个字符全部匹配的结果之和。

class Solution {
public:
    int numDistinct(string s, string t) {
        int len1 = s.size(),len2 = t.size();
        if(len1 == 0 || len1 < len2)
            return 0;
        vector<vector<long> > dp(len2, vector<long>(len1,0));
        for(int i=0;i<len2;i++){
            for(int j=0;j<len1;j++){
                if(t[i] == s[j]){
                    if(i == 0)
                        dp[0][j] = 1;
                    else{
                        for(int k=0;k<j;k++)
                            dp[i][j] += dp[i-1][k];
                    }
                }
            }
        }
        int res = 0;
        for(int j=0;j<len1;j++)
            res += dp[len2-1][j];
        return res;
    }
};

动态规划

同样设置一个动态规划数组，dp[i][j] 表示s中范围是 [0, i] 的子串中能组成t中范围是 [0, j] 的子串的子序列的个数。
边界条件：子序列为空时，返回1，即dp[0][j] = 1
dp[i][j] 时，dp[i][j] >= dp[i][j - 1] 总是成立，
当 T[i - 1] == S[j - 1] 时，dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1]，
若不等， dp[i][j] = dp[i][j - 1]，
综合以上，递推式为：
dp[i][j] = dp[i][j - 1] + (T[i - 1] == S[j - 1] ? dp[i - 1][j - 1] : 0)

class Solution {
public:
    int numDistinct(string s, string t) {
        int len1 = s.size(),len2 = t.size();
        if(len1 == 0 || len1 < len2)
            return 0;
        vector<vector<long> > dp(len2+1, vector<long>(len1+1,0));
        for(int i=0;i<=len2;i++){
            for(int j=i;j<=len1;j++){
                if(i == 0) dp[i][j] = 1;
                else{
                    dp[i][j] = t[i-1] == s[j-1] ? dp[i][j-1]+dp[i-1][j-1] : dp[i][j-1];
                }
            }
        }
        return dp[len2][len1];
    }
};