#leetcode#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中有多少个保持原来顺序的subsequence能等于T，

看了很多大牛的博客， 终于明白了，

新建一个二维数组 dp［S.length() + 1］［T.length() + 1］

dp［i］［j］表示在S［0....i］T［0....j］范围内的有效Distinct Subsequence数目， 

如何初始化？

对于S的每一位，i， 当T为空时， 都有一个有效解 －－》 T ＝＝ “”， 所以  for（i ＝ 1 ～ s.length()）, dp[ i ] [ 0 ] = 1

对于S为空， T为空， T本身就是S的一个有效解， 所以  dp［0］［0］ ＝ 1；

对于T的每一位， 当S为空， 不存在任何subsequence， 所以  for（j ＝ 1 ～ t.length()）， dp［0］［j］ ＝  0；

那么怎样从以前的历史数据推出来dp［i］［j］呢？

对于S.charAt( i )  和  T.charAt( j ), 只有两种情况， 要么相同， 要么不同

为了方便理解， 就拿S和T的最后一位来举例：

不同：

S：＊＊＊＊＊＊＊B

       0 1 2 3 4 5 6 7 8

i

T：                  ＊＊A

                         0 1 2

j

不同的时候比较简单， S加上第 j 位的B和不加第 j 位的 B， 对解没有影响，当前位置的有效解数目 等于 T 对应于 B 之前（0 ～ 7）的子序列的有效解数目： dp［i］［j］ ＝ dp［i － 1］［j］

相同：

S：＊＊＊＊＊＊＊A

       0 1 2 3 4 5 6 7 8

i

T：                  ＊＊A

                         0 1 2

j

相同的时候有两种情况：

1）， T 的 A 和 S 的 A match， 配成一对， 那么此时就要看  T 的  ［0， 1］在 S 的 ［0 ～ 7］中有多少个配对， dp［i － 1］［j － 1］

2）， T 的 ［0 ～ 2 ］和 S 的 ［0 ～ 7］之间去配对， dp［i － 1］［j］

所以字符相同时 dp［i］［j］＝ dp［i － 1］［j － 1］ ＋ dp［i － 1］［j］

时间复杂度是O（m ＋ n）

空间复杂度是O（m ＊ n）

实现时注意  i j 的取值 和 String中下标的对应关系

public class Solution {
    public int numDistinct(String s, String t) {
        if(s == null){
            return 0;
        }
        if(t == null){
            return 1;
        }
        int[][] dp = new int[s.length() + 1][t.length() + 1];
        // dp[0][0] == 1, 空string有一个空string作为subsequence
        for(int i = 0; i < s.length(); i++){
            dp[i][0] = 1;
        }
        for(int i = 1; i < t.length(); i++){
            dp[0][i] = 0;
        }
        for(int i = 1; i <= s.length(); i++ ){
            for(int j = 1; j <= t.length(); j++){
                // if(s.charAt(i) != t.charAt(j))  {
                if(s.charAt(i - 1) != t.charAt(j - 1)){
                    dp[i][j] = dp[i - 1][j];
                }else{
                    dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
                }
            }
        }
        
        return dp[s.length()][t.length()];
    }
}

接下来考虑一下省空间， dp［i］［j］仅由 dp［i － 1］［j］和 dp［i － 1］［j － 1］决定，也就是只由上一行决定

优化到滚动数组是可以实现的

下面的解只是吧上面解的一行拿出来做一维数组， 两个一维数组来回赋值， 注意一维数组的第一个元素是1， dp［0］＝ 1， 对应于上面的初始化dp［i］［0］＝ 1

public class Solution {
    public int numDistinct(String s, String t) {
        if(s == null){
            return 0;
        }
        if(t == null){
            return 1;
        }
        int[] dp = new int[t.length() + 1];
        dp[0] = 1;   // 对应之前的dp［i］［0］ ＝ 1
       
        for(int i = 1; i <= s.length(); i++ ){
            int [] newline = new int[t.length() + 1];
            newline[0] = 1; // 对应之前的dp［i］［0］ ＝ 1
            for(int j = 1; j <= t.length(); j++){
                if(s.charAt(i - 1) != t.charAt(j - 1)){
                    newline[j] = dp[j];
                }else{
                    newline[j] = dp[j - 1] + dp[j];
                }
            }
            dp = newline;
        }
        
        return dp[t.length()];
    }
}

那能不能再优化呢？ 

当然可以， 一般两个数组都可以优化成只用一个数组， 

如果仍然从左往右loop， 因为dp［j］ 的值取决于 上一行历史信息中的 dp［j］和 dp［j － 1］， 所以写入dp［j］会覆盖 j 位置的历史信息， 导致 求 dp［j ＋ 1］的时候所需的dp［j］不是正确值，

有两种方法， 

一种是把 历史信息中的 dp［j］用一个变量cache起来， 然后求dp［j ＋ 1］的时候  dp［j＋ 1］ ＝ dp［j ＋ 1］＋ cache，

另一种方法是  因为  dp［j］只由 j 位置 和 j － 1位置的历史信息决定， 所以从后往前loop是不会覆盖历史信息的

解法如下：

public class Solution {
    public int numDistinct(String s, String t) {
        if(s == null){
            return 0;
        }
        if(t == null){
            return 1;
        }
        int[] dp = new int[t.length() + 1];
        dp[0] = 1;   // 对应之前的dp［i］［0］ ＝ 1
       
        for(int i = 1; i <= s.length(); i++ ){
            for(int j = t.length(); j >= 1; j--){
                if(s.charAt(i - 1) != t.charAt(j - 1)){
                    dp[j] = dp[j];
                }else{
                    dp[j] = dp[j - 1] + dp[j];
                }
            }
        }
        return dp[t.length()];
    }
}