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

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.

This problem is a typical dp problem.. we need to maintain  a dp array to find the result by sequence.

here I have two approaches one I need to use O(m.n) space one need to just use O(m) space.

The time complexity is always the same. O(m.n) because we need to travesal the two strings

the first method is to  maintain DP[n][m]

code is as follow

class Solution:
    # @return an integer
    def numDistinct(self, S, T):
        dp=[[0 for j in range(len(T)+1)] for i in range(len(S)+1)]
        for i in range(len(S)+1):
            dp[i][0]=1
        for i in range(1,len(S)+1):
            for j in range(1,len(T)+1):
                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[-1][-1]

second method saves more space but we need to reversed the order

class Solution:
    # @return an integer
    def numDistinct(self, S, T):
        if len(S)==0:
            return 0
        if len(T)==0:
            return 1### 
        res=[0 for j in range(len(T)+1)]
        res[0]=1
        for  i in range(len(S)):
            for j in reversed(range(len(T))):
                if S[i]==T[j]:
                    res[j+1]=res[j]+res[j+1]
        return res[len(T)]