Distinct Subsequences

1.题目

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

子序列字符串是原始字符串通过删除一些(或零个)产生的一个新的字符串，并且对剩下的字符的相对位置没有影响。(比如，“ACE”是“ABCDE”的子序列字符串,而“AEC”不是)。

样例

给出S = "rabbbit", T = "rabbit"

返回 3

2.算法

这道题可以用动态规划，

动态规划，定义dp[i][j]为字符串i变换到j的变换方法。
如果S[i]==T[j]，那么dp[i][j] = dp[i-1][j-1] + dp[i-1][j]。意思是：如果当前S[i]==T[j]，那么当前这个字母即可以保留也可以抛弃，所以变换方法等于保留这个字母的变换方法加上不用这个字母的变换方法。
如果S[i]!=T[i]，那么dp[i][j] = dp[i-1][j]，意思是如果当前字符不等，那么就只能抛弃当前这个字符。
递归公式中用到的dp[0][0] = 1，dp[i][0] = 0（把任意一个字符串变换为一个空串只有一个方法）

    public int numDistinct(String S, String T)
    {
        // write your code here
    	if (S.length() == 0)
    	{
    		return 0;
    	}
        if(T.length() == 0)  
        {  
            return 1;  
        }  
    	int[][] res = new int[S.length() + 1][T.length() + 1];
    	res[0][0] = 1;
    	for (int i = 0; i < S.length(); i++)
    	{
    		res[i][0] = 1;
    	}
    	for (int i = 1; i <= S.length(); i++)
    	{
    		for (int j = 1; j <= T.length(); j++)
    		{
    			res[i][j] = res[i - 1][j];
    			if (S.charAt(i - 1) == T.charAt(j - 1))
    			{
    				res[i][j] += res[i - 1][j - 1];
    			}
    		}
    	}
    	return res[S.length()][T.length()];
    }

这里用了2维数组，怎样用一维数组来做呢，由于递归关系式为dp[i][j] = dp[i-1][j-1] + dp[i-1][j]，其中等式右边第一维不变，所以每次用一个数组表示第二维，每次更新第2维，由于数算出[j-1]和[j]的值付给[j]，所以要先算出后面的值，所以第二层扫描要从后往前。

    public int numDistinct(String S, String T)
    {
        // write your code here
    	if (S.length() == 0)
    	{
    		return 0;
    	}
        if(T.length()==0)  
        {  
            return 1;  
        }  
    	int[] res = new int[T.length() + 1];
    	res[0] = 1;
    	for (int i = 0; i < S.length(); i++)
    	{
    		for (int j = T.length() - 1; j >= 0; j--)
    		{
    			res[j + 1] = (S.charAt(i) == T.charAt(j) ? res[j] : 0) + res[j + 1];
    		}
    	}
    	return res[T.length()];
    }