LeetCode115.不同的子序列

动态规划和递归两种方法，但是递归会超时。

class Solution {
    public int numDistinct(String s, String t) {
        if(s == null || t == null || s.length() < t.length()){
            return 0;
        }
        int m = s.length();
        int n = t.length();
        char[] ss = s.toCharArray();
        char[] tt =  t.toCharArray();
        //return dfs(ss, tt, 0, 0);
        int[][] dp = new int[n + 1][m + 1];
        for(int i = 0; i < m + 1; i++){
            dp[0][i] = 1;
        }
        for(int i = 1; i < n + 1;i++){
            for(int j = 1; j < m + 1; j++){
                if(ss[j - 1] == tt[i - 1])
                    dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
                else    
                    dp[i][j] = dp[i][j - 1]; 
            }
        }
        return dp[n][m];
    }
    //递归的办法超时了
    public int dfs(char[] s, char[] t, int i, int j){
        int m = s.length;
        int n = t.length;

        if(n - j > m - i){
            return 0;
        }

        if(j >= n){
            return 1;
        }

        if(s[i] == t[j]){
            return dfs(s, t, i + 1, j + 1) + dfs(s, t, i + 1, j);
        } else {
            return dfs(s, t, i + 1, j);
        }
    }
    
}