Add comments to explain the solutions

haoel · haoel · commit bc100bce31c4 · 2014-10-25T23:05:57.000+08:00
diff --git a/src/candy/candy.cpp b/src/candy/candy.cpp
@@ -25,6 +25,32 @@ using namespace std;
 
 void print(vector<int> &v);
 
+/*
+ *    The soluiton is O(2n) run-time complexity
+ *
+ *    For example:
+ *
+ *        ratings[] = { 5, 6, 7, 4, 1, 2, 3, 2, 1, 7 } 
+ *
+ *    1) Go through the ratings from left to right.
+ *
+ *       Find the each increasing sub-array, giving the minimal candy     
+ *
+ *        ratings[] = { 5, 6, 7,   4,   1, 2, 3,   2,   1, 7 } 
+ *                      ------>    ->   ------>    ->   --->
+ *          candy[] = { 1, 2, 3,   1,   1, 2, 3,   1,   1, 2 }
+ *
+ *    2) Go through the raings from right to left.
+ *
+ *             ratings[] = { 5,   6,   7, 4, 1,   2,   3, 2, 1,   7 } 
+ *                           <-   <-   <------    <-   <------    <-
+ *          prev_candy[] = { 1,   2,   3, 1, 1,   2,   3, 1, 1,   2 }
+ *                                        +1              +1
+ *               candy[] = { 1,   2,   3, 2, 1,   2,   3, 2, 1,   2 }
+ *
+ *    3) total candy is 19
+ *
+ */
 int candy(vector<int> &ratings) {
 
     vector<int> candyCnt(ratings.size()) ;
@@ -71,5 +97,10 @@ int main(int argc, char**argv)
 
     cout << candy(ratings) << endl;
 
+    cout << "--------------------" << endl;
+    int r[] = { 5, 6, 7, 4, 1, 2, 3, 2, 1, 7 };
+    vector<int> ra(r, r+sizeof(r)/sizeof(r[0]));
+    print(ra);
+    cout << candy(ra) << endl;
     return 0;
 }
diff --git a/src/copyListWithRandomPointer/copyListWithRandomPointer.cpp b/src/copyListWithRandomPointer/copyListWithRandomPointer.cpp
@@ -12,6 +12,8 @@
 *               
 **********************************************************************************/
 
+
+
 /**
  * Definition for singly-linked list with a random pointer.
  * struct RandomListNode {
@@ -20,6 +22,50 @@
  *     RandomListNode(int x) : label(x), next(NULL), random(NULL) {}
  * };
  */
+
+
+/*    
+ *
+ *  The idea as below:
+ *
+ *  Consider we have a linked list as below:
+ *
+ *    node1->random = node2;
+ *    node2->random = node1;
+ *    node3->random = node1;
+ *    
+ *       +-------------+                         
+ *       |             v                         
+ *    +-------+    +-------+    +-------+        
+ *    | node1 |----> node2 |----> node3 |--->NULL
+ *    +-------+    +-------+    +-------+        
+ *      ^  ^           |           |             
+ *      |  +-----------+           |             
+ *      +--------------------------+             
+ *    
+ *
+ *  To copy the list, 
+ *   
+ *    1) We insert a new node for each node's next position
+ *
+ * 
+ *       +-------------------------+                                     
+ *       |                         v                                     
+ *    +--+----+     +-----+    +-------+     +-----+    +-------+        
+ *    | node1 |---> | NEW |----> node2 |---> | NEW |----> node3 |--->NULL
+ *    +-------+     +-----+    +---+---+     +-----+    +--+----+        
+ *      ^  ^                       |                       |             
+ *      |  +-----------------------+                       |             
+ *      +--------------------------------------------------+             
+ *
+ *    2) Then, we can construt the new node's random pointer:
+ *
+ *        (node1->next) -> random  = (node1->random) -> next;
+ *
+ *    3) After we take out all of the "NEW" node to finish the copy.
+ *    
+ */
+
 class Solution {
 public:
     RandomListNode *copyRandomList(RandomListNode *head) {
@@ -62,20 +108,57 @@ class Solution {
         return h;
     }
 };
- 
- 
+
+
+/*
+ *  Considering we have a link as below:
+ *
+ *
+ *       +-------------+
+ *       |             v
+ *    +-------+    +-------+    +-------+
+ *    | node1 |----> node2 |----> node3 |--->NULL
+ *    +-------+    +-------+    +-------+
+ *      ^  ^           |           |
+ *      |  +-----------+           |
+ *      +--------------------------+
+ * 
+ *  1) Using a map to store each node's random pointer's position
+ *
+ *      map[node1->random] = 1;
+ *      map[node2->random] = 0;
+ *      map[node3->random] = 0;
+ *
+ *  2) Clone the linked list (only consider the next pointer)
+ *
+ *      new1 --> new2 --> new3 --> NULL 
+ *
+ *  3) Using an array to strore the order of the cloned linked-list
+ *
+ *      v[0] = &new1
+ *      v[1] = &new2
+ *      v[2] = &new3
+ * 
+ *  4) Then we can clone the random pointers.
+ *
+ *      new->random = v [ map[node->random] ]
+ *
+ */ 
 class MySolution {
 public:
     RandomListNode *copyRandomList(RandomListNode *head) {
+
         RandomListNode *p = NULL, *h=NULL, *t=NULL;
-        
+        //using a map to store the random pointer's postion.
         map<RandomListNode*, int> m;
-        
+        //construct the map
         int pos =0;
         for ( p = head; p != NULL; p = p->next, pos++){
             m[p] = pos;
         }
         
+        //clone the linked list  (only consider the next pointer)
+        //and using a vector to store each node's postion.
         vector<RandomListNode*> v;
         for (p = head; p != NULL; p = p->next){
             RandomListNode *node = new RandomListNode(p->label);
@@ -88,14 +171,17 @@ class MySolution {
             }
         }
 
+        //p => source link head 
+        //t => new link head
+        //move the p and t synchronously, and 
+        //     t->random = vector[ map[p->random] ];
         for (t=h, p = head; t!=NULL && p!= NULL; p=p->next, t=t->next){
             if (p->random!=NULL) {
                 pos = m[p->random];
                 t->random = v[pos];
             }
         }
         
-        
         return h;
         
     }
diff --git a/src/longestConsecutiveSequence/longestConsecutiveSequence.cpp b/src/longestConsecutiveSequence/longestConsecutiveSequence.cpp
@@ -15,6 +15,22 @@
 *               
 **********************************************************************************/
 
+//
+//  Obviously, the easist way is sort the array, however the run-time complexity is O(nlogn)
+//  
+//  If we cannot use the sort algorithm, then it seems we have to use O(n^2) solution.
+//
+//  That's fine, let's take a look the O(n^2) soultion
+//
+//      1) for each item num[i] in the array
+//      2) for loop to seach ...... num[i-2], num[i-1],  num[i]+1, num[i]+2 ......
+//  
+//  We can see, the search is really heavy, and the best data structure for seaching is HashMap.
+//  hash map is O(1) run-time complexity for seaching.
+//
+//  So, we can have the following solution by using Hash Map.
+//   
+
 class Solution {
 public:
     int longestConsecutive(vector<int> &num) {
diff --git a/src/palindromePartitioning/palindromePartitioning.II.cpp b/src/palindromePartitioning/palindromePartitioning.II.cpp
@@ -40,44 +40,46 @@ int minCut(string s) {
     return minCut_DP(s);
 }
 
-//DP
-
 /*
-
-Define res[i] = the minimum cut from 0 to i in the string.
-The result w =e need eventually is res[s.size()-1].
-We know res[0]=0. Next we are looking for the optimal solution function f.
-
-For example, let s = "leet".
-
-f(0) = 0;  // minimum cut of str[0:0]="l", which is a palindrome, so not cut is needed.
-f(1) = 1; // str[0:1]="le" How to get 1? 
-                 f(1) might be:  (1)   f(0)+1=1, the minimum cut before plus the current char.
-                                 (2)   0, if str[0:1] is a palindrome  (here "le" is not )
-f(2) = 1; // str[0:2] = "lee" How to get 2?
-                f(2) might be:   (1)  f(1) + 1=2
-                                 (2)  0, if str[0:2] is a palindrome (here "lee" is not)
-                                 (3)  f(0) + 1,  if str[1:2] is a palindrome, yes! 
-f(3) = 2; // str[0:3] = "leet" How to get 2?
-                f(3) might be:   (1)  f(2) + 1=2
-                                 (2)  0, if str[0:3] is a palindrome (here "leet" is not)
-                                 (3)  f(0) + 1,  if str[1:3] is a palindrome (here "eet" is not)
-                                 (4)  f(1) + 1,  if str[2:e] is a palindrome (here "et" is not)
-OK, output f(3) =2 as the result.
-
-So, the optimal function is:
-
-f(i) = min [  f(j)+1,  j=0..i-1   and str[j:i] is palindrome
-                    0,   if str[0,i] is palindrome ]
-
-The above algorithm works well for the smaller test cases, however for the big cases, it still cannot pass.
-Why? The way we test the palindrome is time-consuming.
-
-Also using the similar DP idea, we can construct the look-up table before the main part above, so that the palindrome testing becomes the looking up operation. The way we construct the table is also the idea of DP.
-e.g.   mp[i][j]==true if str[i:j] is palindrome.
-       mp[i][i]=true;
-       mp[i][j] = true if str[i]==str[j] and (mp[i+1][j-1]==true or j-i<2 )  j-i<2 ensures the array boundary. 
-*/
+ *  Dynamic Programming
+ *  -------------------
+ *
+ *  Define res[i] = the minimum cut from 0 to i in the string.
+ *  The result w =e need eventually is res[s.size()-1].
+ *  We know res[0]=0. Next we are looking for the optimal solution function f.
+ *  
+ *  For example, let s = "leet".
+ *  
+ *  f(0) = 0;  // minimum cut of str[0:0]="l", which is a palindrome, so not cut is needed.
+ *  f(1) = 1; // str[0:1]="le" How to get 1? 
+ *                   f(1) might be:  (1)   f(0)+1=1, the minimum cut before plus the current char.
+ *                                   (2)   0, if str[0:1] is a palindrome  (here "le" is not )
+ *  f(2) = 1; // str[0:2] = "lee" How to get 2?
+ *                  f(2) might be:   (1)  f(1) + 1=2
+ *                                   (2)  0, if str[0:2] is a palindrome (here "lee" is not)
+ *                                   (3)  f(0) + 1,  if str[1:2] is a palindrome, yes! 
+ *  f(3) = 2; // str[0:3] = "leet" How to get 2?
+ *                  f(3) might be:   (1)  f(2) + 1=2
+ *                                   (2)  0, if str[0:3] is a palindrome (here "leet" is not)
+ *                                   (3)  f(0) + 1,  if str[1:3] is a palindrome (here "eet" is not)
+ *                                   (4)  f(1) + 1,  if str[2:e] is a palindrome (here "et" is not)
+ *  OK, output f(3) =2 as the result.
+ *  
+ *  So, the optimal function is:
+ *  
+ *  f(i) = min [  f(j)+1,  j=0..i-1   and str[j:i] is palindrome
+ *                      0,   if str[0,i] is palindrome ]
+ *  
+ *  The above algorithm works well for the smaller test cases, however for the big cases, it still cannot pass.
+ *  Why? The way we test the palindrome is time-consuming.
+ *  
+ *  Also using the similar DP idea, we can construct the look-up table before the main part above, 
+ *  so that the palindrome testing becomes the looking up operation. The way we construct the table is also the idea of DP.
+ *
+ *  e.g.   mp[i][j]==true if str[i:j] is palindrome.
+ *         mp[i][i]=true;
+ *         mp[i][j] = true if str[i]==str[j] and (mp[i+1][j-1]==true or j-i<2 )  j-i<2 ensures the array boundary. 
+ */
 
 
 int minCut_DP(string& s) {
diff --git a/src/palindromePartitioning/palindromePartitioning.cpp b/src/palindromePartitioning/palindromePartitioning.cpp
@@ -38,6 +38,34 @@ bool isPalindrome(string &s, int start, int end)  {
     return true;  
 }  
 
+// DFS - Deepth First Search
+//    
+//   For example: "aaba"
+//    
+//                     +------+           
+//              +------| aaba |-----+     
+//              |      +------+     |     
+//            +-v-+              +-v--+  
+//            | a |aba           | aa |ba
+//        +---+---+--+           +--+-+  
+//        |          |              |    
+//      +-v-+     +--v--+         +-v-+  
+//      | a |ba   | aba |\0       | b |a 
+//      +-+-+     +-----+         +-+-+  
+//        |        a, aba           |    
+//      +-v-+                     +-v-+  
+//      | b |a                    | a |\0
+//      +-+-+                     +---+  
+//        |                      aa, b, a
+//      +-v-+                            
+//      | a |\0                          
+//      +---+                            
+//    a, a, b, a                         
+//
+//   You can see this algorithm still can be optimized, becasue there are some dupliation.
+//   (  The optimization you can see the "Palindrome Partitioning II" )
+//
+   
 void partitionHelper(string &s, int start, vector<string> &output, vector< vector<string> > &result) {
 
     if (start == s.size()) {
@@ -46,8 +74,11 @@ void partitionHelper(string &s, int start, vector<string> &output, vector< vecto
     }
     for(int i=start; i<s.size(); i++) {
         if ( isPalindrome(s, start, i) == true ) {
+            //put the current palindrome substring into ouput
             output.push_back(s.substr(start, i-start+1) );
+            //Recursively check the rest substring
             partitionHelper(s, i+1, output, result);
+            //take out the current palindrome substring, in order to check longer substring.
             output.pop_back();
         }
     }
diff --git a/src/wordLadder/wordLadder.II.cpp b/src/wordLadder/wordLadder.II.cpp
@@ -39,6 +39,40 @@
 #include <unordered_set>
 using namespace std;
 
+// Solution
+//
+//      1) Using BSF algorithm build a tree like below
+//      2) Using DSF to parse the tree to the transformation path.
+//
+// For example:
+//
+//     start = "hit"
+//     end = "cog"
+//     dict = ["hot","dot","dog","lot","log","dit","hig", "dig"]
+//
+//                      +-----+
+//        +-------------+ hit +--------------+
+//        |             +--+--+              |
+//        |                |                 |
+//     +--v--+          +--v--+           +--v--+
+//     | dit |    +-----+ hot +---+       | hig |
+//     +--+--+    |     +-----+   |       +--+--+
+//        |       |               |          |
+//        |    +--v--+         +--v--+    +--v--+
+//        +----> dot |         | lot |    | dig |
+//             +--+--+         +--+--+    +--+--+
+//                |               |          |
+//             +--v--+         +--v--+       |
+//        +----> dog |         | log |       |
+//        |    +--+--+         +--+--+       |
+//        |       |               |          |
+//        |       |    +--v--+    |          |
+//        |       +--->| cog |<-- +          |
+//        |            +-----+               |
+//        |                                  |
+//        |                                  |
+//        +----------------------------------+
+
 map< string, unordered_set<string> >& 
 buildTree(string& start, string& end, unordered_set<string> &dict) {
 
diff --git a/src/wordLadder/wordLadder.cpp b/src/wordLadder/wordLadder.cpp
