不同的子序列

可以用动态规划来解决。
dp[i][j] 表示S中前i个到T中前j个有多少种解法。我们考虑新来了一个元素在i中，如果
S[i] ！= T[j]则应该删除它才有可能成功，所以此时

$$dp[i][j] = dp[i-1][j]$$
如果S[i] == T[i][j]则可以考虑删或者不删，删了的话则有和上一样的公式，如果不删则是固定S的i和S的j这种考虑，所以为dp[i-1][j-1]。所以有：
$$dp[i][j]=dp[i-1][j]+dp[i-1][j-1]$$

class Solution {
public:    
    /**
     * @param S, T: Two string.
     * @return: Count the number of distinct subsequences
     */
    int numDistinct(string &S, string &T) {
        // write your code here
        vector<vector<int>> dp(S.length()+1,vector<int>(T.length()+1));
        for(int i = 0; i < S.length()+1; ++i){
            dp[i][0] = 1;
        }
        for(int i = 1; i < T.length()+1; ++i){
            dp[0][i] = 0;
        }
        for(int i = 1; i < S.length()+1; ++i){
            for(int j = 1; j < T.length()+1; ++j){
                dp[i][j] = dp[i-1][j];
                if(S[i-1]==T[j-1]) {
                    dp[i][j] += dp[i-1][j-1];
                }
            }
        }
        return dp[S.length()][T.length()];
    }
};

注意由于我们加入了空集这样的边界条件（这样其实很棒～如下图），所以遍历从下标 1 开始，所以判断的时候是s[i-1] T[j-1]。

有注意到状态j只和状态j-1有关系，可以用滚动数组～改成：

class Solution {
public:    
    /**
     * @param S, T: Two string.
     * @return: Count the number of distinct subsequences
     */
    int numDistinct(string &S, string &T) {
        // write your code here
        vector<int> res(T.size()+1,0);
        res[0] = 1;
        for(int i = 1; i < S.size()+1; ++i){
            int pre = 1;
            for(int j = 1; j < T.size()+1; ++j){
                int temp = res[j];
                if(S[i-1] == T[j-1]) res[j] += pre;
                pre = temp;
            }
        }
        return res[T.size()];
    }
};