Distinct Subsequences Solution Write-up

Author: haoel

src/distinctSubsequences/distinctSubsequences.cpp

@@ -17,28 +17,112 @@
 * 
 *               
 **********************************************************************************/
-
+#include <stdlib.h>
+#include <time.h>
 #include <string.h>
 #include <iostream>
 #include <string>
 #include <map>
 #include <vector>
 using namespace std;
 
+//=====================
+// Dynamic Programming
+//=====================
+//
+//  The idea as below:
+//
+//     Considering m[i][j] means the distance from T[i] to S[j], and add the empty "" case, then,
+//
+//     A) Initialization for empty case:  m[0][j] = 1;
+//
+//     B) Calculation 
+//
+//        a) Target-len > Source-len cannot found any substring
+//           i > j : m[i][j] = 0;   
+//
+//        b) if not equal, take the value of T[i] => S[j-1] (e.g. ["ra" => "rabb"] =["ra" => "rab"] )
+//           S[j] != T[i] :  m[i][j] = m[i][j-1]
+//
+//        c) if equal. (e.g.  ["rab" => "rabb"] = ["rab" =>"rab"] + ["ra" => "rab"] ) 
+//           S[j] == T[i] :  m[i][j] = m[i][j-1] + m[i-1][j-1]
+//
+//  1) Initialize a table as below   
+//       ""  r  a  b  b  b  i  t
+//    ""  1  1  1  1  1  1  1  1
+//    r     
+//    b   
+//    t  
+//
+//  2) Calculation
+//       ""  r  a  b  b  b  i  t
+//    ""  1  1  1  1  1  1  1  1
+//    r   0  1  1  1  1  1  1  1 
+//    b   0  0  0  1  2  3  3  3
+//    t   0  0  0  0  0  0  0  3
+//
+int numDistinct1(string S, string T) {
+    vector< vector<int> > m(T.size()+1, vector<int>(S.size()+1));
+    
+    for (int i=0; i<m.size(); i++){
+        for (int j=0; j<m[i].size(); j++){
+
+            if (i==0){
+                m[i][j] = 1;
+                continue;
+            }
+            if ( i>j ) {
+                m[i][j] = 0;
+                continue;
+            }
+            if (S[j-1] == T[i-1]){
+                m[i][j] = m[i][j-1] + m[i-1][j-1];
+            } else {
+                m[i][j] = m[i][j-1] ;
+            }
+        }
+    }
+    return m[T.size()][S.size()];
+}
 
-//Dynamic Programming
-int numDistinct(string S, string T) {
+
+//=====================
+// Dynamic Programming
+//=====================
+//
+//  The idea here is an optimization of above idea 
+//  (It might be difficult to understand if you don't know the above idea)
+//
+//    For example:
+//
+//      S = "abbbc"  T="abb"
+//      posMap = { [a]={0}, [b]={1,2} }
+//      numOfSubSeq = {1, 0, 0, 0 }
+//
+//      S[0] is 'a', pos is 0,  numOfSubSeq = {1, 0+1, 0, 0};
+//
+//      S[1] is 'b', pos is 2,  numOfSubSeq = {1, 1, 0, 0+0};
+//                   pos is 1,  numOfSubSeq = {1, 1, 0+1, 0};
+//
+//      S[2] is 'b', pos is 2,  numOfSubSeq = {1, 1, 1, 0+1};
+//                   pos is 1,  numOfSubSeq = {1, 1, 1+1, 1};
+//
+//      S[3] is 'b', pos is 2,  numOfSubSeq = {1, 1, 2, 2+1};
+//                   pos is 1,  numOfSubSeq = {1, 1, 1+2, 3};
+//
+//      S[4] is 'c', not found, numOfSubSeq = {1, 1, 3, 3};
+// 
+//
+int numDistinct2(string S, string T) {
 
     map< char, vector<int> > pos_map;
     int len = T.size();
-    int *numOfSubSeq = new int[len+1];
-    memset(numOfSubSeq, 0, sizeof(int) * (len+1) );
+    vector<int> numOfSubSeq(len+1);
     numOfSubSeq[0] = 1;
 
     for (int i=len-1; i>=0; i--){
         pos_map[T[i]].push_back(i);
     }
-   
 
     for (int i=0; i<S.size(); i++){
         char ch = S[i];
@@ -50,11 +134,22 @@ int numDistinct(string S, string T) {
         }
     }
 
-    int result = numOfSubSeq[len];
-    delete[] numOfSubSeq; 
-    return result;
+    return numOfSubSeq[len];
 }
 
+
+//random invoker
+int numDistinct(string S, string T) {
+    srand(time(0));
+    if (rand()%2){
+        cout << "-----Dynamic Programming Method One-----" << endl;
+        return numDistinct1(S,T);
+    }
+    cout << "-----Dynamic Programming Method Two-----" << endl;
+    return numDistinct2(S,T);
+}
+
+
 int main(int argc, char** argv)
 {
     string s = "rabbbit";