115. Distinct Subsequences

最新推荐文章于 2021-08-15 20:07:33 发布

原创最新推荐文章于 2021-08-15 20:07:33 发布 · 132 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode 同时被 3 个专栏收录

89 篇文章

订阅专栏

leetcode

85 篇文章

订阅专栏

算法

83 篇文章

订阅专栏

本文介绍了一种使用动态规划解决字符串子序列计数问题的方法，通过详细的步骤解析和示例代码，展示了如何计算一个字符串通过删减字符得到另一个字符串的方法总数。

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

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).

Here is an example:
S = "rabbbit", T = "rabbit"

Return 3.

题意：

给出两个字符串，求第一个字符串通过删减字符得到第二个的方法总数。

思路：

妈呀，可真难想。动态规划怎么这么难呢，看答案看半天才懂。

首先用一个二维vector dp[i][j]表示s的前i个字符删减得到t的前j个字符的方法数。如果s[i]==t[j],那么dp[i][j]=dp[i-1][j-1]+dp[i-1][j]，因为s的前i个字符和t的前j个字符，如果要s的最后一个的话，那么方法数就是dp[i-1][j-1]，如果不用的话，那就是dp[i-1][j]。否则如果s[i]!=t[j]，那么想用s最后一个也用不了，dp[i][j]=dp[i-1][j].

注意初始化的问题，i个字符删减得到0个字符的方法数为1,0个字符删减得到i个字符的方法数为0,dp[0][0]=1.

同时可以降维，减少空间复杂度。注意内层循环只能自顶向下，不能自底向上，联系到01背包与完全背包的区别，因为一个前者只能拿一次，后者无限次，同样的，本题中，自底向上会多次加f[j-1]。

代码：

class Solution {
public:
    int numDistinct(string s, string t) {
        int l1=s.length();
        int l2=t.length();
        if(l2>l1||(l1==l2&&s!=t))
            return 0;
        if(s==t)
            return 1;
        //  vector<vector<int> > dp(l1+ 1, vector<int>(l2+ 1, 0)); 
        // //int dp[l1+1][l2+1];
        // for(int i=0;i<l1;i++)
        //     dp[i][0]=1;
        // dp[0][0]=1;
        // for(int i=1;i<=l1;i++)
        // {
        //     for(int j=1;j<=l2;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[l1][l2];
        //int f[l2+1];
        vector<int>f(l2+1);
        f[0]=1;
        for(int i=0;i<l1;i++)
        {
            for(int j=l2;j>=1;j--)
            {
                f[j]+=s[i]==t[j-1]?f[j-1]:0;
            }
        }
        return f[l2];
    }
};