Add comments to explain the solution

haoel · haoel · commit 0858fdb3d9c4 · 2014-10-25T14:03:40.000+08:00
diff --git a/src/LRUCache/LRUCache.cpp b/src/LRUCache/LRUCache.cpp
@@ -22,6 +22,12 @@
 #include <map>
 using namespace std;
 
+// The idea here is quite simple:
+//    1) A Map to index the key.  O(1) key search time-complexity.
+//    2) A List to sort the cache data by accessed time.
+// 
+//  Considering there are too many insert/delete opreations for the List, 
+//  The ouble linked list is the good data structure to performance it.
 
 class Node {
     public:
@@ -32,6 +38,7 @@ class Node {
         //Node(int k, int v, Node* n=NULL, Node* p=NULL): key(k), value(v), next(n), prev(p) {}
 };
 
+// the following double linked list seems a bit commplicated.
 class DoubleLinkedList {
 
     private:
@@ -151,8 +158,11 @@ class DoubleLinkedList {
 class LRUCache{
 
     private:
+        //cacheList - store the date
         DoubleLinkedList cacheList;
+        //cacheMap - index the date for searching
         map<int, Node*> cacheMap;
+        //the max capcity of cache
         int capacity;
 
     public:
@@ -164,6 +174,7 @@ class LRUCache{
         }
 
         int get(int key) {
+            // The accessed node must be up-to-time -- take to the front 
             if (cacheMap.find(key) != cacheMap.end() ){
                 cacheList.TakeToBegin(cacheMap[key]);
                 return cacheMap[key]->value;
@@ -173,12 +184,15 @@ class LRUCache{
         }
 
         void set(int key, int value) {
+            // key found, update the data, and take to the front 
             if (cacheMap.find(key) != cacheMap.end() ){
                 Node *p = cacheMap[key];
                 p->value = value;
                 cacheList.TakeToBegin(cacheMap[key]);
             }else{
+                // key not found, new a node to store data
                 cacheMap[key] = cacheList.NewAtBegin(key, value);
+                // if the capacity exceed, remove the last one.
                 if( cacheList.Size() > capacity) {
                     int key = cacheList.GetTailNode()->key; 
                     cacheMap.erase(key);
diff --git a/src/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp b/src/binaryTreePostorderTraversal/binaryTreePostorderTraversal.cpp
@@ -38,6 +38,11 @@ struct TreeNode {
 vector<int> postorderTraversal1(TreeNode *root);
 vector<int> postorderTraversal2(TreeNode *root);
 
+
+// We have two methods here.
+//   1) the first one acutally is pre-order but reversed the access order.
+//   2) the second one is the traditional one 
+
 vector<int> postorderTraversal(TreeNode *root) {
     if (random()%2){
         cout << "---method one---" << endl;
@@ -47,6 +52,7 @@ vector<int> postorderTraversal(TreeNode *root) {
     return postorderTraversal2(root);
 }
 
+
 vector<int> postorderTraversal1(TreeNode *root) {
     vector<int> v;
     vector<TreeNode*> stack;
@@ -56,6 +62,7 @@ vector<int> postorderTraversal1(TreeNode *root) {
     while (stack.size()>0){
         TreeNode *n = stack.back();
         stack.pop_back();
+        //the tricks: reverse the access order.
         v.insert(v.begin(), n->val);
         if (n->left){
             stack.push_back(n->left);
@@ -67,6 +74,8 @@ vector<int> postorderTraversal1(TreeNode *root) {
     return v;
 }
 
+// traditional and standard way.
+// using the stack to simulate the recursive function stack.
 vector<int> postorderTraversal2(TreeNode *root) {
     vector<int> v;
     vector<TreeNode*> stack;
@@ -75,13 +84,16 @@ vector<int> postorderTraversal2(TreeNode *root) {
     while(stack.size()>0 || node!=NULL){
 
         if (node != NULL){
+            // keep going the left
             stack.push_back(node);
             node = node->left;
         }else{
             TreeNode *n = stack.back();
+            // left way is finsised, keep going to the right way
             if (n->right != NULL && lastVisitNode != n->right){
                 node = n->right;
             }else{
+                // both left and right has been accessed.
                 stack.pop_back();
                 v.push_back(n->val);
                 lastVisitNode = n;
diff --git a/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.II.cpp b/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.II.cpp
@@ -65,6 +65,7 @@ int findMin(vector<int> &num) {
         }
     }
     
+    // checking the edge case 
     if (high == low) return num[low];
     return num[low] < num[high] ? num[low] : num[high];
 
diff --git a/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp b/src/findMinimumInRotatedSortedArray/findMinimumInRotatedSortedArray.cpp
@@ -21,26 +21,40 @@
 #include <vector>
 using namespace std;
 
+/* 
+ *  Obveriously, to search any sorted array, the binary search is the common sense.
+ * 
+ *  To solve this problem, the idea is same as the search in rotated sorted array.
+ */
 int findMin(vector<int> &num) {
 
     int low=0, high=num.size()-1;
 
     while(high-low>1){
         int mid = low + (high-low)/2;
+        // Chek the array if it is non-rotated, then just return the first element.
         if (num[low] < num[mid] && num[mid] < num[high]){
-            return num[low] < num[mid] ? num[low] : num[mid];
+            return num[low];
         }
+
+        // The array is rotated
+        // Spli it into two part, the minimal value must be the rotated part
+        
+        // if the left part is rotated, warch the left part
         if (num[low] > num [mid]){
             high = mid;
             continue;
         }
+        // if the right part is rotated, search the right part.
         if (num[mid] > num[high]){
             low = mid;
             continue;
         }
     }
-    
+    // the array only has 1 element
     if (high == low) return num[low];
+
+    // the array has 2 elements
     return num[low] < num[high] ? num[low] : num[high];
 
 }
diff --git a/src/maxPointsOnALine/maxPointsOnALine.cpp b/src/maxPointsOnALine/maxPointsOnALine.cpp
@@ -22,7 +22,7 @@ struct Point {
     Point(int a, int b) : x(a), y(b) {}
 };
 
-// O^2 solution
+// O(n^2) time complexity solution
 int maxPoints(vector<Point> &points) {
 
     #define INT_MAX 2147483647
@@ -32,25 +32,39 @@ int maxPoints(vector<Point> &points) {
     if (points.size()<=2) return points.size();
     
     int maxnum = 0;
+    //using a map to find the same slope line
     map<double, int> slopeMap;
+
+    //The algorithm here is quite straight forward.
+    //   take each point in array to caculate with others
+    //
+    //Actually the algorithm here can be optimized.
+    //   there are many duplicated calculation. 
+    //   considering two points A and B, (A,B) is same with (B,A), here re-calculated.
     for(int i=0; i<points.size(); i++) {
+        //reset teh slope map.
         slopeMap.clear();
         slopeMap[INT_MIN] = 0;
         int samePointCnt = 1;
         for (int j=0; j<points.size(); j++) {
-            if (i==j) continue;
+            if (i==j) continue; //skip the same point
+            //Caculate the slope of two points
             int delta_x = points[i].x - points[j].x;
             int delta_y = points[i].y - points[j].y;
+            //Special case: two points are exactly at same place
             if (delta_y == 0 && delta_x == 0){
                 samePointCnt++;
                 continue;
             }
+            //Special case: delta_x == 0
             double slope = INT_MAX;
             if (delta_x!=0) {
                 slope = 1.0*delta_y / delta_x;
             }
+            //Count the points is same line.
             slopeMap[slope]++;
         }
+        //find the max number of points located at same line with points[i]
         map<double, int>::iterator it;
         for (it = slopeMap.begin(); it != slopeMap.end(); it++) {
             if (maxnum < it->second + samePointCnt) {
diff --git a/src/maximumProductSubarray/maximumProductSubarray.cpp b/src/maximumProductSubarray/maximumProductSubarray.cpp
@@ -10,23 +10,47 @@
 * For example, given the array [2,3,-2,4],
 * the contiguous subarray [2,3] has the largest product = 6.
 * 
+* More examples:
+*   
+*   Input: arr[] = {6, -3, -10, 0, 2}
+*   Output:   180  // The subarray is {6, -3, -10}
+*   
+*   Input: arr[] = {-1, -3, -10, 0, 60}
+*   Output:   60  // The subarray is {60}
+*   
+*   Input: arr[] = {-2, -3, 0, -2, -40}
+*   Output:   80  // The subarray is {-2, -40}
 *               
 **********************************************************************************/
 
 #include <iostream>
 #include <algorithm>
 using namespace std;
 
+// The idea is similar with "Find the subarray wich has the largest sum"
+// (See: http://en.wikipedia.org/wiki/Maximum_subarray_problem)
+// 
+// The only thing to note here is, maximum product can also be obtained by minimum (negative) product 
+// ending with the previous element multiplied by this element. For example, in array {12, 2, -3, -5, -6, -2}, 
+// when we are at element -2, the maximum product is multiplication of, minimum product ending with -6 and -2.
+//
 int maxProduct(int A[], int n) {
 
+    // To remember the max/min product for previous position
+    int maxPrev = A[0], minPrev = A[0];
+    // To remember the max/min product for current position
     int maxHere = A[0], minHere = A[0];
+    // Overall maximum product
     int maxProd = A[0];
-    int maxPrev = A[0], minPrev = A[0];
 
     for (int i=1; i<n; i++){
+        //max( maxPrev * A[i],  minPrev * A[i],  A[i] )
         maxHere = max( max( maxPrev * A[i], minPrev * A[i] ), A[i] );
+        //min( maxPrev * A[i],  minPrev * A[i],  A[i] )
         minHere = min( min( maxPrev * A[i], minPrev * A[i] ), A[i] );
+        //Keep tracking the overall maximum product
         maxProd = max(maxHere, maxProd);
+        //Shift the current max/min product to previous variables
         maxPrev = maxHere;
         minPrev = minHere;
     }
@@ -45,4 +69,7 @@ int main()
 
     int b[] = {-1, -1};
     TEST(b);
+
+    int c[] = {-1, 0, -2};
+    TEST(c);
 }
diff --git a/src/wordBreak/wordBreak.II.cpp b/src/wordBreak/wordBreak.II.cpp
@@ -29,6 +29,34 @@
 #include <map>
 using namespace std;
 
+// ---------------
+//  Recursive Way
+// ---------------
+// The recursive method is quite straight forward.
+//
+//    1) if a substring from 0 to i is a word, then take the rest substring to evaluate. 
+//    2) during the recursion, keep tracking the result
+//
+//  For example:
+//
+//    s = "catsanddog",
+//    dict = ["cat", "cats", "and", "sand", "dog"].
+//
+//       
+//                            +---> sand / dog ---> dog           
+//                            |                   
+//         +-------> cat / sanddog                 
+//         |                                      
+//       catsanddog                               
+//          |                                     
+//          +------> cats / anddog                  
+//                            |                    
+//                            +----> and / dog ---> dog           
+//       
+//
+// However, the recursive could produce a lot duplicated calculation, we need use a cache to avoid.
+//
+
 //To avoid time limit error, need to add cache
 vector<string> wordBreak(string s, set<string> &dict, map<string, vector<string> >& cache) {
 
@@ -66,24 +94,52 @@ void wordBreak(string s, set<string> &dict, string str, vector<string>& result)
     for(int i=0; i<s.size(); i++){
         string w = s.substr(0,i+1);
 
+        // if the current substring is a word
         if (dict.find(w)!=dict.end()) {
             str = org_str;
             if (str.size()>0){
                 str +=" ";
             }
             str = str + w;
 
+            // foud the solution, add it into the result
             if (i==s.size()-1){
                 result.push_back(str);
                 return;
             }
 
+            //recursively to solve the rest subarray
             wordBreak(s.substr(i+1, s.size()-i-1), dict, str, result);
         }
     }
 }
+//---------------------
+// Dynamic Programming
+//---------------------
+//
+//  Define substring[i, j] is the sub string from i to j.
+//
+//       (substring[i,j] == word) :   result[i] = substring[i,j] + {result[j]}
+//
+//      So, it's better to evaluate it backword. 
+//
+//  For example:
+//
+//    s = "catsanddog",
+//    dict = ["cat", "cats", "and", "sand", "dog"].
+//  
+//       0  c  "cat"  -- word[0,2] + {result[3]}  ==> "cat sand dog"
+//             "cats" -- word[0,3] + {result[4]}  ==> "cats and dog" 
+//       1  a  ""
+//       2  t  ""
+//       3  s  "sand" --  word[3,6] + {result[7]} ==> "sand dog"
+//       4  a  "and"  --  word[4,6] + {result[7]} ==> "and dog"
+//       5  n  ""
+//       6  d  ""
+//       7  d  "dog"
+//       8  o  ""
+//       9  g  ""
 
-//Dynamic Programming
 vector<string> wordBreak_dp(string s, set<string> &dict) {
     vector< vector<string> > result(s.size());
 
diff --git a/src/wordBreak/wordBreak.cpp b/src/wordBreak/wordBreak.cpp
@@ -23,15 +23,20 @@ using namespace std;
 
 bool wordBreak(string s, set<string> &dict) {
 
+    //using an array to mark subarray from 0 to i can be broken or not
     vector<bool> v(s.size(),false);
 
     for(int i=0; i<s.size(); i++){
+        //check the substring from 0 to i is int dict or not
         string w = s.substr(0,i+1);
         v[i] = (dict.find(w)!=dict.end());
 
+        //if it is, then use greedy algorithm
         if (v[i]) continue;
 
+        //if it is not, then break it to check
         for(int j=0; j<i; j++){
+            //if the substring from 0 to j can be borken, then check the substring from j to i
             if (v[j]==true){
                 w = s.substr(j+1, i-j);
                 v[i] = (dict.find(w)!=dict.end());

Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,7 @@ int findMin(vector<int> &num) {`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`
	`68`	`+ // checking the edge case`
`68`	`69`	`if (high == low) return num[low];`
`69`	`70`	`return num[low] < num[high] ? num[low] : num[high];`
`70`	`71`