leetcode distinct-subsequences(DP)

参考https://oj.leetcode.com/problems/distinct-subsequences

动态规划方程

 dp[i][j]=dp[i-1][j-1]+dp[i-1][j] (s(i)==t(i))

dp[i][j]=dp[i-1][j];

边界条件：  iif(j==0) d[i][j]=1;    

自己画个矩阵看看。

 可能出错，

1.直接递归超时

 1 public class Solution {

 2     public int numDistinct(String S, String T) {

 3         int len1=S.length();

 4         int len2=T.length();

 5         if(len1<len2) return 0;

 6         

 7         int ans=dp(S,T,len1,len2);

 8         return ans;

 9         

10         

11     }

12     public  int dp(String S,String T,int i,int j)

13     {

14         if(i<j) return 0;

15         if(i==0&&j==0) return 1; // ""  ""

16         if(j==0&&i!=0) return 0;//"xxxx" ""

17        

18         if(S.charAt(i-1)==T.charAt(j-1))

19         {

20             return dp(S,T,i-1,j-1)+dp(S,T,i-1,j);

21         }

22         else  return dp(S,T,i-1,j);

23         

24     }

25 }

View Code

2、加入一个矩阵，依然超时

 1 public class Solution {

 2     public int numDistinct(String S, String T) {

 3         int len1=S.length();

 4         int len2=T.length();

 5         if(len1<len2) return 0;

 6         int d[][]=new int[len1+1][len2+1];

 7         

 8         int ans=dp(S,T,len1,len2,d);

 9         

10         return ans;

11         

12         

13     }

14     public  int dp(String S,String T,int i,int j,int d[][])

15     {

16         if(i<j) return 0;

17         

18         

19         if(i==0&&j==0) return 1; // ""  ""

20         if(i!=0&&j==0) return 0;

21         if(d[i][j]!=0) return d[i][j];

22        

23         if(S.charAt(i-1)==T.charAt(j-1))

24         {

25             d[i-1][j-1]=dp(S,T,i-1,j-1,d);

26             d[i-1][j]=dp(S,T,i-1,j,d);

27             return d[i-1][j-1]+d[i-1][j];

28         }

29         else 

30         {

31             d[i-1][j]=dp(S,T,i-1,j,d);

32             return d[i-1][j];

33         }

34         

35     }

36 }

View Code

3.真正的动态规划

 1 public class Solution {

 2     public int numDistinct(String S, String T) {

 3         int len1=S.length();

 4         int len2=T.length();

 5         if(len1<len2) return 0;

 6         int d[][]=new int[len1+1][len2+1];

 7         for(int i=0;i<=len1;i++)

 8         {

 9             d[i][0]=1;

10         }

11         for(int i=1;i<=len1;i++)

12         {

13             for(int j=1;j<=len2&&j<=i;j++)

14             {

15                 if(S.charAt(i-1)==T.charAt(j-1))

16                 {

17                     d[i][j]=d[i-1][j-1]+d[i-1][j];

18                 }

19                 else

20                 {

21                     d[i][j]=d[i-1][j];

22                 }

23                 

24                 

25             }

26             

27             

28         }

29         

30         return d[len1][len2];

31         

32        

33         

34     }

35     

36 }

View Code