Distinct Subsequences

https://leetcode.com/problems/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.

解题思路：

这再次是一道题意表述不清的题。按照题目的意思，是找出S中所有T的subsequence。这怎么做？其实题目的意思是，S中所有等于T的subsequence。

先想到dfs。搜索S，所有长度等于T的组合里，看有多少和T相等。代码不难，写出来后发现超时了。如下。

public class Solution {
    public int numDistinct(String S, String T) {
        List<String> result = new ArrayList<String>();
        dfs(T, S, new StringBuffer(), result, 0);
        return result.size();
    }
    
    public void dfs(String T, String S, StringBuffer current, List<String> result, int step) {
        if(current.length() > T.length()){
            return;
        }
        if(current.length() == T.length() && T.equals(current.toString())) {
            result.add(current.toString());
            return;
        }
        if(T.indexOf(current.toString()) != 0) {
            return;
        }
        for(int i = step; i < S.length(); i++) {
            current.append(S.charAt(i));
            dfs(T, S, current, result, i + 1);
            current.deleteCharAt(current.length() - 1);
        }
    }
}

于是参考了别人的解法。这是一道动态规划的题目，不过是二维的dp。动态规划的关键在于定义子状态，这里定义dp[i][j]为S[0..i]中的subsequence等于T[0..j]的数量。

如果S[i]!=T[j]，S[0...i-1]的subsequence等于T[0..j]的有dp[i-1][j]个，那么在这个基础上加上S[i]也没用，所以dp[i][j]=dp[i-1][j]。

如果S[i]==T[j]，那么在上面的基础上加上S[i]就可以了。所以S[0...i-1]的subsequence等于T[0..j-1]的有dp[i-1][j-1]个，因为S[i]==T[j]，在这个基础上S加上S[i]，T加上T[j]，仍然可行，故首先有dp[i-1][j-1]个。还有一种情况，S不加上S[i]，仍然拿S[0..i-1]和T[0..j]比，也就是和上面相同，这种情况下还有dp[i-1][j]个。其实，两种情况就分别是：不用S[i]，以及用S[i]。因而，S[i]==T[j]的情况下，dp[i][j]=dp[i-1][j]+dp[i-1][j-1]。

递推方程出来了，动态规划还要解决初始值的问题。对于S=""的情况，也就是i==0，显然所有的dp=0。对于T==""的情况，也就是j==0，dp=1。因为S里的子串等于空的也就一种可能。

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

这还是比较复杂的一道动态规划，因为是二维，状态递推方程也略微复杂，需要细细体会。

update 2015/06/28:

更新了一个滚动数组的方法，因为原来的二维数组，本行的值仅仅依赖于上一行的值，所以实际上二维是不需要的。但是必须注意因为dp[j]依赖于dp[j-1]，所以第二层循环必须从后往前。

public class Solution {
    public int numDistinct(String s, String t) {
        int[] dp = new int[t.length() + 1];
        dp[0] = 1;
        for(int i = 1; i <= s.length(); i++) {
            //因为dp[j]依赖于dp[j-1]，所以本层循环必须从后往前
            for(int j = t.length(); j >= 1; j--) {
                // dp[j] = dp[j];
                if(s.charAt(i - 1) == t.charAt(j - 1)) {
                    dp[j] += dp[j - 1];
                }
            }
        }
        return dp[t.length()];
    }
}