Distinct Subsequences

最新推荐文章于 2017-09-08 08:43:10 发布

愤怒的猴子

最新推荐文章于 2017-09-08 08:43:10 发布

阅读量271

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签： java leetcode 动态规划

本文链接：https://blog.youkuaiyun.com/yeshiwu/article/details/51752277

leetcode 专栏收录该内容

175 篇文章

订阅专栏

解决一个字符串中另一字符串的不同子序列计数问题，通过深度优先搜索优化至动态规划方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目描述：

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.

这个题首先想到的dfs，然后写了下面的代码。想都不想就超时了：

public class Solution {  
    public int numDistinct(String s, String t) {
        return getNumDistinct(s, 0, t, 0);
    }
    
    public int getNumDistinct(String s, int sStart, String t, int tStart){
        if(s.length()-sStart<t.length()-tStart){
            return 0;
        }
        if(tStart==t.length()) return 1;
        if(sStart==s.length()){
            return 0;
        }
        if(s.charAt(sStart)!=t.charAt(tStart)){
            return getNumDistinct(s, sStart+1, t, tStart);
        }else{
            return getNumDistinct(s, sStart+1, t, tStart+1)+getNumDistinct(s, sStart+1, t, tStart);
        }
    }
}

然后就是在这里加入备忘录，用dp记录下s[sStart, s.length-1]中包含t[tStart, t.length-1]的子串数。

时间性能增强很多，但是会出现这个错误：Line 32: java.lang.StackOverflowError。内存溢出，也就是递归调用次数多了。还是得转换成自下而上的dp算法才行！

public class Solution {  
    public int numDistinct(String s, String t) {
		int slen=s.length(),tlen=t.length();
		int[][] dp=new int[slen+1][tlen+1];
		for(int i=0;i<=slen;i++){
			for(int j=0;j<=tlen;j++){
				dp[i][j]=Integer.MAX_VALUE;
			}
		}
        int num= getNumDistinct(s, 0, t, 0, dp);
        return num;
    }
	
	public int getNumDistinct(String s, int sStart, String t, int tStart, int[][] dp){
		if(s.length()-sStart<t.length()-tStart){
			dp[sStart][tStart]=0;
			return 0;
		}
		if(tStart==t.length()){
			dp[sStart][tStart]=1;
			return 1;
		}
		if(sStart==s.length()){
			dp[sStart][tStart]=0;
			return 0;
		}
		if(s.charAt(sStart)!=t.charAt(tStart)){
			if(dp[sStart+1][tStart]!=Integer.MAX_VALUE){
				dp[sStart][tStart]=dp[sStart+1][tStart];
				return dp[sStart+1][tStart];
			}else{
				int a = getNumDistinct(s, sStart+1, t, tStart, dp);
				dp[sStart][tStart]=a;
				return a;
			}
		}else{
			int dp1=0,dp2=0;
			if(dp[sStart+1][tStart+1]!=Integer.MAX_VALUE){
				dp1=dp[sStart+1][tStart+1];
			}else{
				dp1=getNumDistinct(s, sStart+1, t, tStart+1, dp);
			}
			if(dp[sStart+1][tStart]!=Integer.MAX_VALUE){
				dp2=dp[sStart+1][tStart];
			}else{
				dp2=getNumDistinct(s, sStart+1, t, tStart, dp);
			}
			dp[sStart][tStart]=dp1+dp2;
			return dp1+dp2;
		}
	}
}

AC代码如下：

动态规划，定义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 class Solution {  
    public int numDistinct(String S, String T) {  
        if(S==null||T==null) {  
            return 0;  
        }  
        if(S.length()<T.length()) {  
            return 0;  
        }  
        int [][] dp = new int[S.length()+1][T.length()+1];  
        dp[0][0] = 1; 
        for(int i=0;i<S.length();i++) {  
            dp[i][0] = 1;      
        } 
        for(int i=1;i<=S.length();i++) {  
            for(int j=1;j<=T.length();j++) {  
                dp[i][j] = dp[i-1][j];  
                if(S.charAt(i-1)==T.charAt(j-1)) {  
                    dp[i][j] += dp[i-1][j-1];  
                }  
            }  
        }  
        return dp[S.length()][T.length()];  
    }  
}