Add comments to explain the solutions

Author: haoel

src/largestRectangleInHistogram/largestRectangleInHistogram.cpp

@@ -22,22 +22,93 @@
 #include <vector>
 using namespace std;
 
+// As we know, the area = width * height
+// For every bar, the 'height' is determined by the loweset bar.
+//
+// 1) We traverse all bars from left to right, maintain a stack of bars. Every bar is pushed to stack once. 
+// 2) A bar is popped from stack when a bar of smaller height is seen. 
+// 3) When a bar is popped, we calculate the area with the popped bar as smallest bar. 
+// 4) How do we get left and right indexes of the popped bar – 
+//    the current index tells us the ‘right index’ and index of previous item in stack is the ‘left index’. 
+//
+//
+// In other word, the stack only stores the incresing bars, let's see some example  
+//
+// Example 1
+// ---------
+// height = [1,2,3,4]
+//
+//    stack[] = [ 0, 1, 2, 3 ], i=4
+//
+//    1) pop 3,  area = height[3] * 1 = 4
+//    2) pop 2,  area = height[2] * 2 = 4
+//    3) pop 1,  area = height[1] * 3 = 6
+//    4) pop 0,  area = height[0] * 4 = 4
+//
+//
+// Example 2
+// ---------
+// height = [2,1,2]
+//
+//    stack[] = [ 0 ], i=1
+//    1) pop 0,  area = height[0] * 1 = 2
+//
+//    stack[] = [ 1,2 ], i=3, meet the end
+//    1) pop 2,  area = height[2] * 1 = 2
+//    2) pop 1,  area = height[1] * 3 = 3
+//
+//
+// Example 3
+// ---------
+// height =  [4,2,0,3,2,5]  
+//
+//    stack[] = [ 0 ], i=1, height[1] goes down
+//    1) pop 0,  area = height[0] * 1 = 4
+//
+//    stack[] = [ 1 ], i=2, height[2] goes down
+//    1) pop 1,  area = height[1] * 2 = 4 // <- how do we know the left?
+//                                              start from the 0 ?? 
+//
+//    stack[] = [ 2, 3 ], i=4, height[4] goes down
+//    1) pop 3,  area = height[3] * 1 = 3
+//    2) pop 2,  area = height[2] * ? = 0 // <- how do we know the left? 
+//                                              start from the 0 ??
+//
+//    stack[] = [ 2,4,5 ], i=6,  meet the end
+//    1) pop 5,  area = height[5] * 1 = 5
+//    2) pop 4,  area = height[4] * 3 = 6 // <- how do we know the left?
+//                                              need check the previous item.
+//    3) pop 2,  area = height[2] * ? = 4 // <- how do we know the left?
+//                                              start from the 0 ??
+//
+//    so, we can see, when the stack pop the top, the area formular is 
+//
+//          height[stack_pop] *  i - stack[current_top] - 1,   if stack is not empty
+//          height[stack_pop] *  i,                            if stack is empty
+//
 int largestRectangleArea(vector<int> &height) {
     if (height.size()<=0) return 0;
+    //Create an empty stack.
     vector<int> stack;
+    //add a flag as a trigger if the end bar is met, and need to check the stack is empty of not .
     height.push_back(0);
     int maxArea = 0;
     for(int i=0; i<height.size(); i++){
+        //If stack is empty or height[i] is higher than the bar at top of stack, then push ‘i’ to stack.
         if ( stack.size()<=0 || height[i] >= height[stack.back()] ) {
             stack.push_back(i);
             continue;
         }
+        //If this bar is smaller than the top of stack, then keep removing the top of stack while top of the stack is greater. 
+        //Let the removed bar be height[top]. Calculate area of rectangle with height[top] as smallest bar. 
+        //For height[top], the ‘left index’ is previous (previous to top) item in stack and ‘right index’ is ‘i’ (current index).
         int topIdx = stack.back();
         stack.pop_back();
         int area = height[topIdx] * (stack.size()==0 ? i : i - stack.back() - 1 );
         if ( area > maxArea ) {
             maxArea = area;
         }
+        //one more time. Because the stack might still have item.
         i--;
     }
 

src/maximalRectangle/maximalRectangle.cpp

@@ -15,6 +15,18 @@
 #include <vector>
 using namespace std;
 
+// The problem can be convert to the problem - "Largest Rectangle in Histogram"
+//   1) we can take each row to calculate each row's histogram.
+//   2) using the algorithm of "Largest Rectangle in Histogram" to find the largest area histogram.
+//   3) tracking the maximal area.
+//
+// For the 1), it's easy. 
+//     heights[i][j] = 1,                     if (i==0)
+//     heights[i][j] = heights[i-1][j] + 1;,  if (i>0)
+//
+// For the 2), please referr to "Largest Rectangle in Histogram"
+// 
+
 int largestRectangleArea(vector<int> &height) {
 
     if (height.size()<=0) return 0;
@@ -44,11 +56,7 @@ int maximalRectangle(vector<vector<char> > &matrix) {
     if (matrix.size()<=0 || matrix[0].size()<=0) return 0;
     int row = matrix.size();
     int col = matrix[0].size();
-    vector< vector<int> > heights(row);
-    for (int i=0; i<row; i++){
-        vector<int> v(col);
-        heights[i] = v;
-    }
+    vector< vector<int> > heights(row, vector<int> col);
 
     int maxArea = 0;
     for(int i=0; i<row; i++){

src/recoverBinarySearchTree/recoverBinarySearchTree.cpp

@@ -42,6 +42,23 @@
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
+
+//
+// We can convert the BST to a sorted array,  then we can find the two nodes which missed the order.
+//
+// To cover the BST to sorted array, we needn't use an extra array, we just traverse the tree in order.
+//  
+//                   8
+//           _______/ \_______
+//          /                 \
+//         4                  12
+//      __/ \__             __/ \__
+//     /       \           /       \
+//    2         6        10        14
+//   / \       / \       / \       / \
+//  1   3     5   7     9  11    13  15
+//  
+//  
 class Solution {
 public:
     void recoverTreeHelper(TreeNode *root) {
@@ -53,10 +70,8 @@ class Solution {
             if (prev->val > root->val){
                 if (n1==NULL) {
                     n1 = prev;
-                    n2 = root;
-                }else{
-                    n2 = root;
                 }
+                n2 = root;
             }
         }
         prev = root;

src/scrambleString/scrambleString.cpp

@@ -47,12 +47,23 @@
 *               
 **********************************************************************************/
 
+#include <stdlib.h>
+#include <time.h>
 #include <iostream>
+#include <vector>
 #include <string>
 #include <algorithm>
 using namespace std;
 
-bool isScramble(string s1, string s2) {
+// The recursive way is quite simple.
+//    1) break the string to two parts: 
+//          s1[0..j]   s1[j+1..n]
+//          s2[0..j]   s2[j+1..n]
+//    2) then
+//          isScramble(s1[0..j], s2[0..j]) &&  isScramble(s1[j+1..n], s2[j+1..n])
+//        OR
+//          isScramble(s1[0..j], s2[j+1, n]) &&  isScramble(s1[j+1..n], s2[0..j])
+bool isScramble_recursion(string s1, string s2) {
 
     if (s1.size()!= s2.size() || s1.size()==0 || s2.size()==0) {
         return false;
@@ -69,12 +80,12 @@ bool isScramble(string s1, string s2) {
     }
 
     for (int i=1; i<s1.size(); i++) {
-        if ( isScramble(s1.substr(0,i), s2.substr(0,i)) && 
-             isScramble(s1.substr(i, s1.size()-i), s2.substr(i, s2.size()-i)) ) {
+        if ( isScramble_recursion(s1.substr(0,i), s2.substr(0,i)) && 
+             isScramble_recursion(s1.substr(i, s1.size()-i), s2.substr(i, s2.size()-i)) ) {
             return true;
         }
-        if ( isScramble(s1.substr(0,i), s2.substr(s2.size()-i, i)) && 
-             isScramble(s1.substr(i, s1.size()-i), s2.substr(0, s2.size()-i)) ) {
+        if ( isScramble_recursion(s1.substr(0,i), s2.substr(s2.size()-i, i)) && 
+             isScramble_recursion(s1.substr(i, s1.size()-i), s2.substr(0, s2.size()-i)) ) {
             return true;
         }
     }
@@ -83,6 +94,79 @@ bool isScramble(string s1, string s2) {
 
 }
 
+/* 
+ *  Definition
+ *  
+ *      dp[k][i][j] means:
+ *  
+ *         a) s1[i] start from 'i'
+ *         b) s2[j] start from 'j'
+ *         c) 'k' is the length of substring
+ *  
+ *  Initialization     
+ *  
+ *      dp[1][i][j] = (s1[i] == s2[j] ? true : false)
+ *  
+ *  Formula
+ *  
+ *      same as the above recursive method idea
+ *  
+ *      dp[k][i][j] = 
+ *          dp[divk][i][j] && dp[k-divk][i+divk][j+divk] ||
+ *          dp[divk][i][j+k-divk] && dp[k-divk][i+divk][j]
+ *  
+ *      `divk` mean split the k to two parts, so 0 <= divk <= k;
+*/
+bool isScramble_dp(string s1, string s2) {
+
+    if (s1.size()!= s2.size() || s1.size()==0 || s2.size()==0) {
+        return false;
+    }
+    if (s1 == s2){
+        return true;
+    }
+
+    const int len = s1.size();    
+    
+    // dp[len+1][len][len]
+    vector< vector< vector<bool> > > dp(len+1, vector< vector<bool> >(len, vector<bool>(len) ) );
+   
+    // ignor the k=0, just for readable code.
+
+    // initialization k=1
+    for (int i=0; i<len; i++){
+        for (int j=0; j<len; j++) {
+            dp[1][i][j] = (s1[i] == s2[j]);
+        }
+    } 
+    // start from k=2 to len, O(n^4) loop. 
+    for (int k=2; k<=len; k++){
+        for (int i=0; i<len-k+1; i++){
+            for (int j=0; j<len-k+1; j++){
+                dp[k][i][j] = false;
+                for (int divk = 1; divk < k && dp[k][i][j]==false; divk++){
+                    dp[k][i][j] = ( dp[divk][i][j] && dp[k-divk][i+divk][j+divk] ) ||
+                                  ( dp[divk][i][j+k-divk] && dp[k-divk][i+divk][j] );
+                }
+            }
+        }
+    }
+    
+    return dp[len][0][0];
+}
+
+bool isScramble(string s1, string s2) {
+
+    srand(time(0));
+
+    if (random()%2) {
+        cout << "---- recursion ---" << endl;
+        return isScramble_recursion(s1, s2);
+    }
+    cout << "---- dynamic programming ---" << endl;
+    return isScramble_dp(s1, s2);
+}
+
 int main(int argc, char** argv)
 {
     string s1="great", s2="rgtae";