LeetCode 115. Distinct Subsequences

Problem Statement

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

Solution 1 - Backtracking

# TLE
class Solution1(object):
    def numDistinct(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: int
        """
        res = [0]
        self.bt(s, t, res, [], 0)
        return res[0]


    def bt(self, s, t, res, ass, start_index):
        """
        :type s: str
        :type t: str
        :type res: list
        :type ass: list
        :type start_index: int
        :rtype: None
        """
        if len(ass) > len(t) or len(ass) + len(s) - start_index < len(t):
            return
        elif len(ass) == len(t):
            if ''.join(ass) == t:
                res[0] += 1
        else:
            for index in xrange(start_index, len(s)):
                ass.append(s[index])
                self.bt(s, t, res, ass, index + 1)
                ass.pop()

Solution 2 - Dynamic Programming

class Solution(object):
    def numDistinct(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: int
        """
        m, n = len(t), len(s)
        dp = [[0 for j in xrange(n + 1)] for i in xrange(m + 1)]
        for j in xrange(n + 1):
            dp[0][j] = 1
        for i in xrange(1, m + 1):
            for j in xrange(1, n + 1):
                dp[i][j] = dp[i][j-1]
                if t[i-1] == s[j-1]:
                    dp[i][j] += dp[i-1][j-1]
        return dp[-1][-1]

Complexity Analysis:

• Time Complexity: $O(m \cdot n)$.
• Space Complexity: $O(m \cdot n)$.