[Leetcode] 115. Distinct Subsequences

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.

两种做法，第一种是recursion：

举个例子，比如String T = "abc" String S = "abcabc"

当T里的某一位，比如说第一位，"a" 匹配上S里的某一位，也比如说第一位里的"a"，那么有两种情况

1. 用上这个匹配，我们再去递归求String T = "bc" 在String S ="bcabc"里出现的次数，这里就有三次，也就是说"abc"在"abcabc"中也有三次，因为两个String首字母a是相同的，我们用上这个

2. 或者不用这个匹配，我们递归去求String T = "abc"  在String S = "bcabc"里出现的次数，这里就是一次。

所以总共是4次。

public class Solution {  
    public int numDistinct(String S, String T) {  
        if (T.length()==0) return 1;  
        if (S.length()==0) return 0;  
        if (T.length()>S.length()) return 0;  
        if (T.charAt(0)!=S.charAt(0))  
            return numDistinct(S.substring(1),T);  
        else return numDistinct(S.substring(1),T) + numDistinct(S.substring(1),T.substring(1));  
    }  
}  

还可以用DP，一般两个字符串匹配很容易想到的就是DP，和recursion的思想是差不多的。

dp[i][j]代表String T的前i位与String S前j位存在序列的个数，和Interleaving String ，Edit Distance差不多

用我们刚才Recursion做出的归纳：当S中某个字符和T中某个字符匹配的时候：

1. 如果两个字符相同，用这个字符，在矩阵里的表示便为累加上之前dp[i-1][j-1]的值

2. 不用这个字符，在矩阵里的表示便为累加上之前dp[i][j-1]的值

如果S的第i个字符和T的第j个字符相同，那么所有dp[i-1][j-1]中满足的结果都会成为新的满足的序列，当然dp[i-1][j]的也仍是可行结果，所以dp[i][j]=res[i-1][j-1]+res[i-1][j]。

遇到这种两个串的问题，很容易想到DP。但是这道题的递推关系不明显。可以先尝试做一个二维的表int[][] dp，用来记录匹配子序列的个数（以S="rabbbit",T = "rabbit"为例）：

    r a b b b i t

  1 1 1 1 1 1 1 1

r 0 1 1 1 1 1 1 1

a 0 0 1 1 1 1 1 1

b 0 0 0 1 2 3 3 3

b 0 0 0 0 1 3 3 3

i 0 0 0 0 0 0 3 3

t 0 0 0 0 0 0 0 3  

从这个表可以看出，无论T的字符与S的字符是否匹配，dp[i][j] = dp[i][j - 1].就是说，假设S已经匹配了j - 1个字符，得到匹配个数为dp[i][j - 1].现在无论S[j]是不是和T[i]匹配，匹配的个数至少是dp[i][j - 1]。除此之外，当S[j]和T[i]相等时，我们可以让S[j]和T[i]匹配，然后让S[j - 1]和T[i - 1]去匹配。所以递推关系为：

dp[0][0] = 1; // T和S都是空串.

dp[0][1 ... S.length() - 1] = 1; // T是空串，S只有一种子序列匹配。

dp[1 ... T.length() - 1][0] = 0; // S是空串，T不是空串，S没有子序列匹配。

比如rab b 和ra b ，如果我们不用rab b 的b，就看rab有多少个rab子串，如果我们用rabb的b，也就是说rabb的b和rab的b匹配，我们只要看rab和ra的匹配数即可。

public class Solution {
    public int numDistinct(String S, String T) {
        if(S == null || T == null || S.length() < T.length()) return 0;
        int[][] num = new int[S.length() + 1][T.length() + 1];
        for(int i = 0; i <= S.length(); i++){
            num[i][0] = 1;
        }
        for(int i = 1; i <= S.length(); i++){
            for(int j = 1; j <= T.length(); j++){
                num[i][j] += num[i - 1][j];
                if(S.charAt(i - 1) == T.charAt(j - 1)){
                    num[i][j] += num[i - 1][j - 1];
                }
            }
        }
        return num[S.length()][T.length()];
    }
}