[Leetcode]115. Distinct Subsequences

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

原创最新推荐文章于 2024-02-14 11:24:21 发布 · 129 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 专栏收录该内容

37 篇文章

订阅专栏

本文探讨了两种解决子序列计数问题的方法：递归与动态规划。首先，介绍了简单但效率较低的递归解决方案，该方法直接依据问题定义进行计算，但由于重复计算导致时间复杂度过高。随后，提出了优化的动态规划方案，通过预计算和存储中间结果，显著提高了算法效率，将时间复杂度降低到O(mn)，空间复杂度为O(n)。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

第一个递归版本，会TLE，很简单，不用几行

class Solution {
public:
    int numDistinct(string s, string t) {
        if(s.size() < t.size() ) return 0;
        if(s == t) return 1;
        if(s[0] == t[0]){
            return numDistinct(s.substr(1),t.substr(1)) + numDistinct(s.substr(1),t);
        } 
        else return numDistinct(s.substr(1),t);
    }
};

时间复杂度o(s.size() * t.size())

空间复杂度 o(1)

第二个版本，动态规划

时间复杂度o(mn),空间o(n)

class Solution {
public:
    int numDistinct(string s, string t) {
        int m = t.size();
        int n = s.size();
        int dp[m+1][n+1];
       
        //善于把递归转换成动态规划
        for(int i = 0; i <= m; i++){
            dp[i][0] = 0;
        }
        for(int j = 0; j <= n; j++){
            dp[0][j] = 1;
        }
        for(int i = 1; i <= m ; ++i){
            for(int j = 1; j <= n; ++j){
                dp[i][j] = dp[i][j-1] + (t[i-1] == s[j-1]? dp[i-1][j-1] : 0);
            }
        }
        return dp[m][n];
    }
};