【Leetcode】115. Distinct Subsequences

Description:

　　Given two string S and T, you need to count the number of T's subsequences appeared in S. The fucking problem description is so confusing.

Input:

　　String s and t

output:

　　The number

Analysis:

　　It's a dynamic processing problem. I drew the dynamic processing of counting the seq numbers and then got the correct formula by guessing? :) Most times I work out the final formula by deducing! Then i back to think it's real sense in the problem.

dp[i][j] represents the number of subsequences in string T (ending before index i)  are appeared in string S (ending before index j). So, dp can be processed by the follow formula:

　　　　　　= dp[i][j-1] + dp[i-1][j-1]     if s[j] == t[i]

　dp[i][j]

= dp[i][j-1]                          if s[j] != t[i]

BYT:

　　The fucking input size of test cases in serve are ambiguity! So if you create a 2-dimension array in defined size, you will be in trouble. Dynamic structures like vector will be better!

Code:

class Solution {
public:
    int numDistinct(string s, string t) {
        if(s.length() ==  || t.length() == ) return ;
        //int dp[50][10908];
        vector<vector<int>> dp(t.length() + , vector<int>(s.length() + , ));
        dp[][] = (t[] == s[])?:;
        for(int i = ; i < s.length(); i ++){
            if(s[i] == t[]) dp[][i] = dp[][i - ] + ;
            else dp[][i] = dp[][i - ];
        }
        for(int i = ; i < t.length(); i ++){
            dp[i][i - ] = ;
            for(int j = i; j < s.length(); j ++){
                dp[i][j] = (t[i] == s[j])? (dp[i][j - ] + dp[i - ][j - ]):dp[i][j - ];
            }
        }
        return dp[t.length() - ][s.length() - ];
    }
};