leetcode【115】Distinct Subsequences

问题描述：

Given a string S and a string T, count the number of distinct subsequences of S which equals T.

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).

It's guaranteed the answer fits on a 32-bit signed integer.

Example 1:

Input: S = "rabbbit", T = "rabbit"
Output: 3
Explanation:
As shown below, there are 3 ways you can generate "rabbit" from S.
(The caret symbol ^ means the chosen letters)

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

Example 2:

Input: S = "babgbag", T = "bag"
Output: 5
Explanation:
As shown below, there are 5 ways you can generate "bag" from S.
(The caret symbol ^ means the chosen letters)

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

源码：

很明显的动态规划。注意一定要用Long或者unsigned int，否则会报错。还有就是注意边界，尽量多设置一维度。

dp[i][j] = s[i-1]==t[j-1]? dp[i-1][j-1]+dp[i-1][j]: dp[i-1][j]

class Solution {
public:
    int numDistinct(string s, string t) {
        long l1 = s.length(), l2 = t.length();
        vector<vector<long>> dp(l1+1, vector<long>(l2+1, 0));
        for(int i=0; i<=l1; i++)    dp[i][0] = 1;
        // for(int i=0; i<=l2; i++)    dp[0][i] = 0;
        for(int i=1; i<=l1; i++){
            for(int j=1; j<=l2 && j<=i; j++){
                if(s[i-1] == t[j-1])    dp[i][j] = dp[i-1][j-1] + dp[i-1][j];
                else    dp[i][j] = dp[i-1][j];
            }
        }
        return dp[l1][l2];
    }
};

i, j返回来的话貌似会好一点，应为少遍历了一些元素。

class Solution {
public:
    int numDistinct(string s, string t) {
        long l1 = s.length(), l2 = t.length();
        vector<vector<long>> dp(l2+1, vector<long>(l1+1, 0));
        for(int i=0; i<=l1; i++)    dp[0][i] = 1;
        // for(int i=0; i<=l2; i++)    dp[0][i] = 0;
        for(int i=1; i<=l2; i++){
            for(int j=i; j<=l1; j++){
                dp[i][j] = s[j-1]==t[i-1]? dp[i-1][j-1]+dp[i][j-1] : dp[i][j-1];
            }
        }
        return dp[l2][l1];
    }
};

我翻了翻DISCUSS区，有个大佬方法，展示一下，空间时间都是100%。就是用一层代替两层，思路有点不清晰，也不常规，就不解释了。

class Solution {
public:

//用了两种方法，第一种是一种递归的方法，如果s[i]和t[0]相等，匹配s[i+1~size]和t[1~size]
//为了加快速度，我采用了一个map，map的key是s的长度<<5+t的长度，对应值为该情况下的结果数。
//无奈怎么优化，该算法都会超时。

//现在的方法，用一个flag[i]存对应于匹配到t[i]的个数
//如果用s中的每一个字母与t[i]想对比，如果i-2的flag==0，break，因为还没匹配到这呢
//如果相等，如果i==0，flag[0]++,如果i！=0，flag[i]+=flag[i-1].
//返回最后一位的flag，即flag[size-1]
	int numDistinct(string s, string t) {
		int size1=s.length();
		int size2=t.length();
		int i,j,res=0;
		
		if(!size2)
			return 0;
		long flag[100];
		for(i=0;i<100;i++)
			flag[i]=0;
		for(i=0;i<size1;i++){
			char temp=s[i];
			
			for(j=0;j<size2;j++)
				if(j>0&&flag[j]==0&&flag[j-1]==0)
					break;
					
			for(j=j-1;j>=0;j--)
				if(temp==t[j])
					if(!j)
						flag[j]++;
					else 
						flag[j]+=flag[j-1];
		}
		
		return flag[size2-1];
	}
};