leetcode_115. 不同的子序列

给定一个字符串 S 和一个字符串 T，计算在 S 的子序列中 T 出现的个数。

一个字符串的一个子序列是指，通过删除一些（也可以不删除）字符且不干扰剩余字符相对位置所组成的新字符串。（例如，“ACE” 是 “ABCDE” 的一个子序列，而 “AEC” 不是）

示例 1:

输入: S = “rabbbit”, T = “rabbit”
输出: 3
解释:

如下图所示, 有 3 种可以从 S 中得到 “rabbit” 的方案。
(上箭头符号 ^ 表示选取的字母)

rabbbit
^^^^ ^^
rabbbit
^^ ^^^^
rabbbit
^^^ ^^^

示例 2:

输入: S = “babgbag”, T = “bag”
输出: 5
解释:

如下图所示, 有 5 种可以从 S 中得到 “bag” 的方案。
(上箭头符号 ^ 表示选取的字母)

babgbag
^^   ^
babgbag
^^         ^
babgbag
^         ^^
babgbag
    ^     ^^
babgbag
         ^^^

解析：看到两个字符串应该可以想到尝试用动态规划去做，想不出来的可以不想。
动态规划最重要的就是状态转移方程，即为什么这么做。
我们定义dp[n+1][m+1] ，其中n与m指两个字符串的长度
对于dp[i][j]定义为s字符串的 前i-1个字符组成的字符串 的子序列中，t字符串的前j-1个字符组成的字符串出现的次数。
有递归的味了。

对于s[i-1]与t[j-1]，如果这两个字符相等，则存在两种情况：
1、s[i-1]存在于子序列中，即这两个字符对应相等，则dp[i][j]便取决于dp[i-1][j-1]
2、s[i-1]不存在于子序列中，即这个字符在判断时是被删除的，则dp[i][j]取决于dp[i-1][j]
因此当s[i-1]==t[j-1]时，dp[i][j] = dp[i-1][j] + dp[i-1][j-1]

而当s[i-1]不等于t[j-1]时，上述的情况1便必不可能符合，仅符合情况2，即最后被删除掉。
因此当s[i-1]!=t[i-1]时，dp[i][j] = dp[i-1][j].

另外要考虑动态规划的初始化问题。
我们为dp多申请了一行一列，它们代表空字符串
于是dp[i][0]即第一列，代表t = “” ,因为空字符串是所有字符串的子集，判断时只要一个个全部删掉就可以得到，因此第一列全部初始化为1。
dp[0][j]即第一行，代表s = “” ,空字符串肯定没有子序列，因此第一行全部初始化为0。

class Solution {
public:
    int numDistinct(string s, string t) {
        int n = s.size();
        int m = t.size();
        if(n==0) return 0;
        if(m==0) return 1;
        //int不够大，会溢出
        vector<vector<long>> dp(n+1,vector<long>(m+1,0)); 
        for(int i=0;i<=n;++i) dp[i][0]=1;
        for(int i=1;i<=n;++i){
            for(int j=1;j<=m;++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[n][m];
    }
};

发现实际时间利用率空间利用率并不高。
仔细观察整个算法，对于每一行，它用到的数据只有上一行的数据，其他的数据再也没有用了。
因此可以将二维数组减小为一维数组，仅储存每一行的数据。下一行计算时直接覆盖。

class Solution {
public:
    int numDistinct(string s, string t){
        int n = s.size();
        int m = t.size();
        if(n==0) return 0;
        if(m==0) return 1;
        vector<long> dp(m+1,0);
        dp[0]=1;
        for(int i=1;i<=n;++i){
            int pre = 1; 
            for(int j=1;j<=m;++j){
                int tmp = dp[j]; //dp[i-1][j];
                if(s[i-1]==t[j-1]) dp[j] += pre; //dp[i-1][j-1];
                pre = tmp;
            }
        }
        return dp[m];
    }
};