LeetCode - Distinct Subsequences

Distinct Subsequences

2014.2.8 22:11

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.

Solution1:

　　The first solution I think of is by recursive searching. After counting the occurrence of every alphabet and recording the indices, we can solve the problem by a recursive search, which ends when the total string T is matched.

　　After testing the code myself, it ran well under small scale, but slowed down in front of long strings, exactly as I expected.

　　If we're to find out a more efficient solution, dynamic programming would be a better strategy:

　　　　1. Let dp[x][y] be the number of possible combinations of T[1:y] in S[1:x].

　　　　2. dp[x][0] = 0.

　　　　3. dp[0][y] = 0.

　　　　4. if S[x] = T[1], dp[x][1] = dp[x - 1][1] + 1, else dp[x][1] = dp[x - 1][1].

　　　　5. if S[x] = T[y], dp[x][y] = dp[x - 1][y] + dp[x - 1][y - 1], else dp[x][y] = dp[x - 1][y].

　　The dynamic programming is O(n^2) scale.

　　Time and space complexities are both O(len(S) * len(T)).

Accepted code:

// 2RE, 1WA, 1AC, don't use memset on dp[][], although it looks as if it were one block of memory.
#include <cstring>
#include <vector>
using namespace std;

class Solution {
public:
    int numDistinct(string S, string T) {
        int **dp;
        int ls, lt;
        int result;
        int i, j;
        
        ls = (int)S.size();
        lt = (int)T.size();
        if (ls == 0 || lt == 0) {
            return 0;
        }
        
        dp = new int*[ls + 1];
        for (i = 0; i < ls + 1; ++i) {
            dp[i] = new int[lt + 1];
        }
        for (i = 0; i <= ls; ++i) {
            for (j = 0; j <= lt; ++j) {
                dp[i][j] = 0;
            }
        }
        /*
        for (i = 0; i <= ls; ++i) {
            dp[i][0] = 0;
        }
        for (i = 0; i <= lt; ++i) {
            dp[0][i] = 0;
        }
        */
        for (i = 1; i <= ls; ++i) {
            if (S[i - 1] == T[0]) {
                dp[i][1] = dp[i - 1][1] + 1;
            } else {
                dp[i][1] = dp[i - 1][1];
            }
        }
        
        for (i = 2; i <= ls; ++i) {
            for (j = 2; j <= lt; ++j) {
                if (S[i - 1] == T[j - 1]) {
                    dp[i][j] = dp[i - 1][j] + dp[i - 1][j - 1];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        result = dp[ls][lt];
        for (i = 0; i < ls + 1; ++i) {
            delete[] dp[i];
        }
        delete[] dp;
        dp = NULL;
        
        return result;
    }
};

 Solution2:

　　The dynamic programming version can be optimized to linear space complexity, using only two rows, switching alternatively.

　　Time complexity is O(len(S) * len(T)). Space complexity is O(len(T)).

Accepted code:

// 2RE, 1WA, 1AC, don't use memset on dp[][], although it looks as if it were one block of memory.
#include <cstring>
#include <vector>
using namespace std;

class Solution {
public:
    int numDistinct(string S, string T) {
        int **dp;
        int ls, lt;
        int result;
        int i, j;
        
        ls = (int)S.size();
        lt = (int)T.size();
        if (ls == 0 || lt == 0 || ls < lt) {
            return 0;
        }
        
        dp = new int*[2];
        for (i = 0; i < 2; ++i) {
            dp[i] = new int[lt + 1];
        }
        for (i = 0; i < 2; ++i) {
            for (j = 0; j <= lt; ++j) {
                dp[i][j] = 0;
            }
        }
        
        if (S[0] == T[0]) {
            dp[1][1] = 1;
        }
        
        int flag;
        flag = 0;
        for (i = 2; i <= ls; ++i) {
            dp[flag][0] = 0;
            if (S[i - 1] == T[0]) {
                dp[flag][1] = dp[!flag][1] + 1;
            } else {
                dp[flag][1] = dp[!flag][1];
            }
            for (j = 2; j <= lt; ++j) {
                if (S[i - 1] == T[j - 1]) {
                    dp[flag][j] = dp[!flag][j] + dp[!flag][j - 1];
                } else {
                    dp[flag][j] = dp[!flag][j];
                }
            }
            flag = !flag;
        }
        flag = !flag;
        result = dp[flag][lt];
        for (i = 0; i < 2; ++i) {
            delete[] dp[i];
        }
        delete[] dp;
        dp = NULL;
        
        return result;
    }
};