commit changes to gh-page aug 13

Author: tg123

_includes/_root/binary-tree-maximum-path-sum/README.md

@@ -1,4 +1,83 @@
+## What will the maximum path look like
+
+Though paths can be starting from any node and end at any node, the appearances only can be:
+
+ * Appearance 1
+
+```
+      *
+     / \
+    *   *
+   /     \ 
+  *       *
+ /         \ 
+S           *
+             \
+              E
+```
+
+ * Appearance 2
+
+```
+      E
+     / 
+    * 
+   / 
+  * 
+ / 
+S           
+```
+
+* Appearance 3
+
+```
+S
+ \
+  *
+   \
+    *
+     \
+      *
+       \
+        E         
+```
+
+### Note
+
+Appearances above are only talking about `TRUNK`.
+
+Treat the path below as Appearance 1
+
+```
+      *
+     / \
+    *   *
+   /     \
+  *       *
+   \     /
+    S   *
+         \
+          E
+```
+
+
+## Tree Version of [Maximum Subarray](../maximum-subarray)
+
+ * Appearance 2/3
+
+These two appearances are easy to understand and to build a path, just take the maximum node. 
+like `Maximum Subarray`, if the sum goes below `0`, forget the old nodes.
+
+ * Appearance 1
+
+If a node's left child or right child is less than `0`, drop it, then the node becomes `Appearance 2/3`.
+ 
+If both the left child and right child are positive, just add them together, `maxPathSum(node.left) + node.val + maxPathSum(node.right)` will be the `maxPathSum` which contains that node.
+
+
+## Put them together
+
+As we know how to find the `maxPathSum` of any node, we can go through the tree and update the max value.
+
 
-## TODO 
-  * write down thinking
 

_includes/_root/combination-sum-ii/Solution.java

@@ -1,12 +1,11 @@
 public class Solution {
-    
     int target;
 
     int[] candidates;
 
     int[] stack;
 
-    ArrayList<ArrayList<Integer>> rt;
+    ArrayList<List<Integer>> rt;
 
     HashSet<String> block;
 
@@ -42,19 +41,17 @@ void search(int sp, int cur){
             stack[sp] = 0;
         }
 
-    }
+    }    
 
-    public ArrayList<ArrayList<Integer>> combinationSum2(int[] num, int target) {
-        // Note: The Solution object is instantiated only once and is reused by each test case.
-        
+    public List<List<Integer>> combinationSum2(int[] num, int target) {
         Arrays.sort(num);
 
         candidates = num;
         this.target = target;
 
         stack = new int[candidates.length];
 
-        rt = new ArrayList<ArrayList<Integer>>();
+        rt = new ArrayList<List<Integer>>();
 
         block = new HashSet<String>();
 
@@ -63,4 +60,4 @@ public ArrayList<ArrayList<Integer>> combinationSum2(int[] num, int target) {
         return rt;
 
     }
-}
+}

_includes/_root/construct-binary-tree-from-inorder-and-postorder-traversal/README.md

@@ -1,4 +1,14 @@
+## Same as [Construct Binary Tree from Preorder and Inorder Traversal](../construct-binary-tree-from-preorder-and-inorder-traversal)
 
-## TODO 
-  * write down thinking
+The difference is run from end to 0 instead of run from 0 to end.
 
+In additional, we should contruct the right tree before the left one.
+
+```
+Pre-order: A, C, E, D, B, H, I, G, F
+                                <- p
+
+In-order:  A, B, C, D, E, F, G, H, I
+                          q
+
+```

_includes/_root/construct-binary-tree-from-preorder-and-inorder-traversal/README.md

@@ -1,4 +1,27 @@
+## Recursion
 
-## TODO 
-  * write down thinking
+```
+Pre-order: F, B, A, D, C, E, G, I, H
+           p
+ 
+In-order:  A, B, C, D, E, F, G, H, I
+                          q
 
+```
+
+From first char `F` in `Pre-order`, we are sure that the root of the tree is `F`.
+
+and from `In-order`, `F` divide the tree into two parts, the left one is  `A, B, C, D, E`, the right one is `G, H, I`.
+
+```
+               F
+             /   \
+A, B, C, D, E     G, H, I
+
+```
+
+`A, B, C, D, E` and `B, A, D, C, E` become a new `buildTree` problem. so we can build the tree recursively. 
+the result tree is the left children of `F`.
+
+
+Similarly, `G, H, I` and `G, I, H` become the right children of `F`.

_includes/_root/generate-parentheses/README.md

@@ -1,4 +1,22 @@
+## Recursion
 
-## TODO 
-  * write down thinking
+### `generateParenthesis(n - i)` and `generateParenthesis(i)`
 
+This problem is a bit like [Unique Binary Search Trees II](../unique-binary-search-trees-ii).
+
+Put left and right generateParenthesis together is OK.
+
+ * `generateParenthesis(n - i)` + `generateParenthesis(i)`
+ * `generateParenthesis(i)` + `generateParenthesis(n - i)`
+
+
+### Special `i = 1`: `generateParenthesis(n - 1)` and `generateParenthesis(1)`
+
+Another new way to generate parenthesis.
+
+ * Surrounding  :`(` + `generateParenthesis(n)` + `)` 
+
+Same as `generateParenthesis(n - i)` and `generateParenthesis(i)`
+ 
+ * `generateParenthesis(n - 1)` + `()`
+ * `()` + `generateParenthesis(n - 1)`

_includes/_root/generate-parentheses/Solution.java

@@ -6,20 +6,23 @@ public List<String> generateParenthesis(int n) {
 
         HashSet<String> temp = new HashSet<String>();
 
-        for(int i = 1; i < n ; i++){
+        for(String s : generateParenthesis(n - 1)){
+            temp.add("(" + s + ")");
+            temp.add("()" + s);
+            temp.add(s + "()");
+        }
+        
+        for(int i = 2; i < n - 1 ; i++){
             for(String s : generateParenthesis(n - i)){
-                if(i == 1) temp.add("(" + s + ")");
-                
                 for(String ss : generateParenthesis(i)){
-                              
+
                     temp.add(ss + s);
                     temp.add(s + ss);
                 }
-      
+
             }
         }
 
         return new ArrayList<String>(temp);
-        
     }
 }

_includes/_root/longest-valid-parentheses/README.md

@@ -1,4 +1,74 @@
+## Counting while [Valid Parentheses](../valid-parentheses)
 
-## TODO 
-  * write down thinking
+When a pair of valid parentheses is found, just add `2` to count.
+
+However, the counting method is a bit tricky. Show you using animation
+
+### Animation
+
+This method adds a counting stack.
+
+```
+input [ ( ( ) ( ) ) ]
+
+count []
+stack []
+ 
+       i
+
+```
+
+No match put `)` and `(` into stack
+
+```
+input [ ) ( ) ) ]
+
+count [ 0 0 ]
+stack [ ( ( ]
+ 
+          i
+
+```
+
+
+
+found matches pop stack and `count[1] =  count[1] + 2`
+
+```
+input [ ( ) ) ]
+
+count [ 0 2 ]
+stack [ ( ]
+ 
+        i
+
+```
+
+just two steps.
+
+found another matches `(` and `)` pop stack and `count[1] =  count[1] + 2`
+
+```
+input [ ]
+
+count [ 0 4 ]
+stack [ ]
+ 
+        i
+
+```
+
+
+found matches, but, this time, `count[0] =  count[0] + 2` is not enough.
+
+It should be `count[0] =  count[0] + 2 + count[1]`, because that here `0` matches parentheses indicates that the current parentheses is enclosing the `1..current`.
+
+
+Generally, when meets a match,
+
+```
+count[stack.size()] =  count[stack.size()] + 2 + count[stack.size() + 1]
+```
+
+then reset the `count[stack.size() + 1]` to `0`.
 

_includes/_root/populating-next-right-pointers-in-each-node/README.md

@@ -1,4 +1,33 @@
+## Recursion
 
-## TODO 
-  * write down thinking
+connecting left and right child is easy, just `node.left.next = node.right`
 
+
+Before 
+
+```
+        1
+       /  \
+      2    3
+     / \  / \
+    4  5  6  7
+```
+
+
+After 
+
+```
+        1
+       /  \
+      2 -> 3
+     / \  / \
+    4-> 5 6->7
+```
+
+`5` and `6` shoud be connected。
+
+when connecting `4` and `5`, `2` and `3` is already connected, that is a good news, we can connect `5` and `6` using `2.next`.
+
+```
+node.right.next = node.next.left;
+```