[LintCode] Distinct Subsequence

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

Example

Given S = "rabbbit", T = "rabbit", return 3.

Challenge 

Do it in O(n2) time and O(n) memory.

O(n2) memory is also acceptable if you do not know how to optimize memory.

 

Solution 1. Recursion

For s[0 ~ n - 1] and t[0 ~ m - 1], there are 2 cases.

case 1. s.charAt(n - 1) != t.charAt(m - 1)

　　　  This means s.charAt(n - 1) can't be used in subsequence of t, so f(s[0 ~ n - 1], t[0 ~ m - 1]) = f(s[0 ~ n - 2], t[0 ~ m - 1]).

case 2. s.charAt(n - 1) == t.charAt(m - 1)

　　　   This means s.charAt(n - 1) can be either used or not used in subsequence of t.

　　　　If it is used, there are f(s[0 ~ n - 2], t[0 ~ m - 2]) distinct subsequences of t in s.

　　　　If it is not used, there are f(s[0 ~ n - 2], t[0 ~ m - 1]) distinct subsequences of t in s.

　　　　so f(s[0 ~ n - 1], t[0 ~ m - 1]) = f(s[0 ~ n - 2], t[0 ~ m - 2]) + f(s[0 ~ n - 2], t[0 ~ m - 1]).

Base case 1.  if t is an empty string, then there is 1 distinct subseqnce of empty string in s.

Base case 2.  if t is longer than s, there is no subsequences of t in s.

It's clear by drawing recursive tree, that this solution has overlapping problems.

 1 public class DistinctSubsequence {
 2     public int getNumOfDistinctSubsequenceRecursion(String s, String t) {
 3         if(s == null || t == null) {
 4             return 0;
 5         }
 6         return recursiveHelper(s, s.length() - 1, t, t.length() - 1);
 7     }
 8     private int recursiveHelper(String s, int endIdx1, String t, int endIdx2) {
 9         if(endIdx2 < 0) {
10             return 1;
11         }
12         if(endIdx1 < endIdx2) {
13             return 0;
14         }
15         if(s.charAt(endIdx1) != t.charAt(endIdx2)) {
16             return recursiveHelper(s, endIdx1 - 1, t, endIdx2);
17         }
18         return recursiveHelper(s, endIdx1 - 1, t, endIdx2 - 1) + recursiveHelper(s, endIdx1 - 1, t, endIdx2);
19     }
20     public static void main(String[] args) {
21         String s1 = "rabbbit", t1 = "rabbit";
22         String s2 = "aabbccdd", t2 = "abcd";
23         String s3 = "rabbbitt", t3 = "rabbit";        
24         String s4 = "", t4 = "";
25         String s5 = "lin", t5 = "lin";
26         String s6 = "lin", t6 = "ling";
27         DistinctSubsequence test = new DistinctSubsequence();
28         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s1, t1));
29         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s2, t2));
30         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s3, t3));
31         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s4, t4));
32         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s5, t5));
33         System.out.println(test.getNumOfDistinctSubsequenceRecursion(s6, t6));
34     }
35 }

 

Solution 2. Dynamic Programming

State: dp[i][j]: the number of distinct subsequence of T[0... j - 1] in S[0... i - 1]

Function:  

If S.charAt(i - 1) can be used to match the last character of T[0...j - 1],  we can either choose to use it or not use it.

If S.charAt(i - 1) can't be used to match the last character of T[0...j - 1], we can only choose not to use it.

The above gives us the following state function.

dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j], if S.charAt(i - 1) == T.charAt(j - 1); 

dp[i][j] = dp[i - 1][j], if S.charAt(i - 1) != T.charAt(j - 1); 

Initialization: dp[0][j] = 0, for j from 1 to T.length(); S is empty string and T is not empty string, no subsequence of T in S;

　　　　　　dp[i][0] = 1, for i from 0 to S.length(); T is empty string, there is always 1 subsequence of T in S, regardless if S is empty or not.

Answer: dp[S.length()][T.length()]

 

 1 public class Solution {
 2     public int numDistinct(String S, String T) {
 3         if(S == null || T == null){
 4             return 0;
 5         }
 6         int n = S.length();
 7         int m = T.length();
 8         int[][] dp = new int[n + 1][m + 1];
 9         for(int j = 0; j <= m; j++){
10             dp[0][j] = 0;
11         }
12         for(int i = 0; i <= n; i++){
13             dp[i][0] = 1;
14         }
15         for(int j = 1; j <= m; j++){
16             for(int i = j; i <= n; i++){
17                 if(S.charAt(i - 1) == T.charAt(j - 1)){
18                     dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
19                 }
20                 else{
21                     dp[i][j] = dp[i - 1][j];
22                 }
23             }
24         }
25         return dp[n][m];
26     }
27 }

 

 

Related Problems 

Interleaving String

转载于:https://www.cnblogs.com/lz87/p/7416795.html