LeetCode OJ-- Distinct Subsequences ** 递推

https://oj.leetcode.com/problems/distinct-subsequences/

对于string S 和 T求，T 是 S的几种子串。

首先想到了递归方法，列出递归公式，奈何超时了：

如果S[sBegin] == T[tBegin] 则是 numSubDistinct(sBegin+1,tBegin+1,S,T) + numSubDistinct(sBegin+1,tBegin,S,T);
如果不等于，则 numSubDistinct(sBegin+1,tBegin,S,T);
如果T的遍历指针到头了，则说明成功了一次匹配

class Solution {
public:
    int numDistinct(string S, string T) {
        int ans = ;
        if(S.size()<T.size())
            return ;
        if(S.size() == T.size())
            if(S == T)
                return ;
            else
                return ;
        return numSubDistinct(,,S,T);
    }
    int numSubDistinct(int sBegin,int tBegin,string &S,string &T)
    {
        if(tBegin== T.size())
            return ;
        if(sBegin == S.size() && tBegin!= T.size())
            return ;
        if(S[sBegin] == T[tBegin])
            return numSubDistinct(sBegin+,tBegin+,S,T) + numSubDistinct(sBegin+,tBegin,S,T);
        else
            return numSubDistinct(sBegin+,tBegin,S,T);
    }
};

之后，考虑用递推实现。

根据思路来说，首先想到从后往前递推，但如果从后往前可以，则从前往后也可以。

建立二维数组num[S.size()][T.size()]存这个过程中产生的中间结果。

首先定义：num[i][j]是对于S从0到 i 的子串，对于T从 0 到 j 的子串，这两个字符串，T是S的子串数。

如果S[sBegin] == T[tBegin] num[sBegin][tBegin] = num[sBegin-1][tBegin-1] + num[sBegin-1][tBegin];

如果不等于则 num[sBegin][tBegin] = num[sBegin-1][tBegin];

根据公式，考虑到进行两层循环，
但是循环之前需要初始化

class Solution {
public:
    int numDistinct(string S, string T) {
        int ans = ;
        if(S.size()<T.size())
            return ;
        if(S.size() == T.size())
            if(S == T)
                return ;
            else
                return ;

        vector<vector<int> > num;
        num.resize(S.size());
        for(int i = ;i<S.size();i++)
            num[i].resize(T.size());

        //initialize
        if(S[] == T[])
            num[][] = ;
        else
            num[][] = ;
        for(int i = ;i<S.size();i++)
        {
            if(S[i] == T[])
                num[i][] = num[i-][] + ;
            else
                num[i][] = num[i-][];
        }

        for(int j = ;j<T.size();j++)
        {
            num[][j] = ;
        }

        for(int sBegin = ;sBegin<S.size();sBegin++)
            for(int tBegin = ;tBegin<T.size();tBegin++)
            {
                if(S[sBegin] == T[tBegin])
                    num[sBegin][tBegin] = num[sBegin-][tBegin-] + num[sBegin-][tBegin];
                else
                    num[sBegin][tBegin] = num[sBegin-][tBegin];
            }

        return num[S.size()-][T.size()-];
    }
};