review

Author: awangdev

Java/3Sum Smaller.java

@@ -8,7 +8,8 @@
 
 ```
 /*
-Given an array of n integers nums and a target, find the number of index triplets i, j, k with 0 <= i < j < k < n that satisfy the condition nums[i] + nums[j] + nums[k] < target.
+Given an array of n integers nums and a target, find the number of index triplets i, j, k with 0 <= i < j < k < n 
+that satisfy the condition nums[i] + nums[j] + nums[k] < target.
 
 For example, given nums = [-2, 0, 1, 3], and target = 2.
 
@@ -38,13 +39,10 @@ public int threeSumSmaller(int[] nums, int target) {
         }
         Arrays.sort(nums);
         int count = 0;
-        int start, end;
-        for (int i = 0; i < nums.length - 2; i++) {
-            int firstNum = nums[i];
-            start = i + 1;
-            end = nums.length - 1;
+        for (int i = 0; i < nums.length - 2; i++) { // first num, num[i] is the fixed item
+            int start = i + 1, end = nums.length - 1;  // move start, end
             while (start < end) {
-                if (nums[i] + nums[start] + nums[end]< target) {
+                if (nums[i] + nums[start] + nums[end] < target) {
                     count += end - start;
                     start++;
                 } else {

Java/3Sum.java

@@ -2,11 +2,11 @@
 1516689562
 tags: Array, Two Pointers
 
-方法1:
-sort array, for loop + two pointer. O(n)
-处理duplicate wthin triplets: 
-如果最外圈的移动点i重复, 一直顺到结尾的最后一个再用.
-如果是triplet内有重复, 用完start point, 移动到结尾.
+
+#### sort array, for loop + two pointer. O(n^2)
+- 处理duplicate wthin triplets: 
+- 如果最外圈的移动点i重复, 一直顺到结尾的最后一个再用.
+- 如果是triplet内有重复, 用完start point, 移动到结尾.
 
 Previous notes:
 注意:   
@@ -52,7 +52,7 @@ Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤
 */
 class Solution {
     public List<List<Integer>> threeSum(int[] nums) {
-        final List<List<Integer>> result = new ArrayList<>();
+        List<List<Integer>> result = new ArrayList<>();
         if (nums == null || nums.length == 0) {
             return result;
         }
@@ -65,8 +65,7 @@ public List<List<Integer>> threeSum(int[] nums) {
             int end = i - 1;
             while (start < end) {
                 if (nums[start] + nums[end] + nums[i] == 0) {
-                    final Integer[] intarr = {nums[start], nums[end], nums[i]};
-                    result.add(Arrays.asList(intarr));
+                    result.add(Arrays.asList(nums[start], nums[end], nums[i]));
                     start++;
                     while (start < end && nums[start - 1] == nums[start]) { // skip duplicates
                         start++;

Java/Accounts Merge.java

@@ -8,7 +8,12 @@
 
 
 #### Union Find
-- 构建 Map<email, email parent>, 然后再反向整合: parent -> list of email
+- 构建 `Map<email, email parent>`, 然后再反向整合: parent -> list of email
+- init with <email, email> for all emails
+- 因为不同account可能串email, 那么把所有email union的时候, 不同account 的email也会被串起来
+- 最终: 所有的email都被union起来, 指向一个各自union的 parent email
+- UnionFind 的 parent map 可以反向输出所有  child under parent.
+- 同时要维护一个 <email -> account name> 的map, 最终用来输出.
 
 #### Hash Table solution, passed but very slow
 - Definitely need iterate over accounts: merge them by email.
@@ -127,7 +132,7 @@ public List<List<String>> accountsMerge(List<List<String>> accounts) {
 
         for (List<String> account : accounts) {
             for (int i = 1; i < account.size() - 1; i++) {
-                union(account.get(i), account.get(i + 1));
+                union(account.get(i), account.get(i + 1));  // email across acounts will be auto-merged/linked in unionFind
             }
         }
 

Java/Combination Sum.java

@@ -20,11 +20,11 @@
 - at each level dfs, we have the index as starting point: 
 - if we are at `index=0, we can have n child dfs() options via for loop`; 
 - if at `index=1, we will have (n-1) dfs options via for loop`. 
-- Consider it as the pick/not-pick proble, where the difference is you can pick `x` times at each index rather than only 2 times. 
+- Consider it as the `pick/not-pick` problem, where the difference is you can pick `x` times at each index rather than only 2 times. 
 - Overall, we will multiply the # of possibilities: n * (n - 1) * (n - 2) ... * 1 = n! => `O(n!)`
 
 ##### Combination DFS 思想
-- 在每个index上面都要面临: pick/not pick的选择
+- 在每个index上面都要面临: `pick/not pick的选择`, 用for loop over index + backtracking 实现 picks.
 - 每次pick以后, 就生成一条新的routine, from this index
 - 下一个level的dfs从这个index开始, 对后面(或者当下/if allow index reuse) 进行同样的 pick/not pick 的选择
 - 注意1: 每个level dfs 里面, for loop 里会有 end condition: 就不必要dfs下去了.

Java/Construct Binary Tree from Preorder and Inorder Traversal.java

@@ -10,7 +10,10 @@
 - 跟Convert Sorted Array to Binary Tree类似, 找到对应的index, 然后:
 - node.left = dfs(...), node.right = dfs(...)
 - Divide and Conquer
-- optimize on finding mid node: given value, find mid of inorder. Instead of searching linearly, just store map <value -> index>, O(1)
+- optimize on finding `mid node`: given value, find mid of inorder:
+- Instead of searching linearly, just store inorder sequence in `map <value -> index>`, O(1)
+- IMPORATANT: the mid from inorder sequence will become the main baseline to tell range: 
+- `range of subTree = (mid - inStart)`
 - sapce: O(n), time: O(n) access
 
 ```

Java/Flatten Binary Tree to Linked List.java

@@ -6,10 +6,10 @@
 
 #### DFS
 - 分析题意后, 按照题意: Flatten the tree, no extra space.
-1. reserve right child
-2. DFS flatten部分
-3. 移花接木
-4. flatten 剩下的.
+- 1. reserve right child: `reservedRightNode`
+- 2. Connect `root.right = root.left`, DFS flatten(root.right) 
+- 3. 移花接木, coneect end of list -> reservedRightNode
+- 4. flatten 剩下的. root.right...
 
 ##### 注意
 - 顺序一定要清楚, 不能写错, 写几个example可以看出来
@@ -88,7 +88,7 @@ public void flatten(TreeNode root) {
             while (node.right != null) {
                 node = node.right;
             }
-            node.right = rightNode;
+            node.right = rightNode; // connect
             flatten(root.right);
         }
     }

Java/Generate Parentheses.java

@@ -48,8 +48,8 @@
 */
 //Faster because StringBuffer object is reused (add/remove elements of it)
 class Solution {
-    private final static String LEFT = "(";
-    private final static String RIGHT = ")";
+    private String LEFT = "(";
+    private String RIGHT = ")";
     public List<String> generateParenthesis(int n) {
         List<String> result = new ArrayList<>();
         if (n == 0) {

Java/Recover Binary Search Tree.java

@@ -7,7 +7,9 @@
 #### Observation
 - BST inorder traversal should give small -> large sequence
 - misplaced means: a **large**->small item would occur, and later a large>**small** would occur. 
-- The first large && second small item are the 2 candidates.
+- The first large && second small item are the 2 candidates. Example
+- [1, 5,  7, 10,    12, 15, 18]
+- [1, 5, `15, 10`, `12,  7`, 18]
 
 #### dfs, O(1) extra space
 - traverse, and take note of the candidate

Java/Strobogrammatic Number II.java

@@ -1,13 +1,14 @@
 M
 1528732676
-tags: Math, DFS, Sequence DFS
+tags: Math, DFS, Sequence DFS, Enumeration
 
 TODO: 
 1. use list, iterative? keep candidates and populating
 2. clean up the dfs code, a bit messy
 3. edge case of "0001000" is invalid, right?
 
 #### DFS
+- A bit like BFS solution: find inner list, and then combine with outter left/right sides.
 - find all solutions, DFS will be easier to write than iterative/BFS
 - when n = 1, there can be list of candidates at bottom of the tree, so bottom->up is better
 - bottom->up, dfs till leaf level, and return candidates.
@@ -34,6 +35,29 @@
 
 */
 
+class Solution {
+    List<String> singleDigitList = new ArrayList<>(Arrays.asList("0", "1", "8"));
+    char[][] digitPair = {{'0', '0'}, {'1', '1'}, {'8', '8'}, {'6', '9'}, {'9', '6'}};
+    public List<String> findStrobogrammatic(int n) {
+        return dfs(n, n);
+    }
+    
+    public List<String> dfs(int n, int max) {
+        if (n <= 0) return new ArrayList<String>(Arrays.asList(""));
+        if (n == 1) return singleDigitList;
+        
+        List<String> subList = dfs(n - 2, max);
+        List<String> list = new ArrayList<>();
+        for (String str : subList) {
+            if (n != max) list.add("0" + str + "0");
+            for (int i = 1; i < digitPair.length; i++) {
+                list.add(digitPair[i][0] + str + digitPair[i][1]);
+            }
+        }
+        return list;
+    }
+}
+
 /*
 Thoughts:
 The items will be in three pattern:
@@ -44,9 +68,9 @@
 Recursion untill n reaches 1
 */
 class Solution {
-    private final List<String> singleDigitList = new ArrayList<>(Arrays.asList("0", "1", "8"));
-    private final List<String> doubleDigitList = new ArrayList<>(Arrays.asList("00", "11", "88", "69", "96"));
-    private final char[][] digitPair = {{'0', '0'}, {'1', '1'}, {'8', '8'}, {'6', '9'}, {'9', '6'}};
+    List<String> singleDigitList = new ArrayList<>(Arrays.asList("0", "1", "8"));
+    List<String> doubleDigitList = new ArrayList<>(Arrays.asList("00", "11", "88", "69", "96"));
+    char[][] digitPair = {{'0', '0'}, {'1', '1'}, {'8', '8'}, {'6', '9'}, {'9', '6'}};
     public List<String> findStrobogrammatic(int n) {
         List<String> result = dfs(n);
         for (int i = 0; i < result.size(); i++) {
@@ -61,15 +85,11 @@ public List<String> findStrobogrammatic(int n) {
 
     public List<String> dfs(int n) {
         List<String> list = new ArrayList<>();
-        if (n <= 0) {
-            return list;
-        }
-        if (n == 1) {
-            return singleDigitList;
-        } else if (n == 2) {
-            return doubleDigitList;
-        }
-        final List<String> subList = dfs(n - 2);
+        if (n <= 0) return list;
+        if (n == 1) return singleDigitList;
+        if (n == 2) return doubleDigitList;
+        
+        List<String> subList = dfs(n - 2);
         for (String str : subList) {
             for (int i = 0; i < digitPair.length; i++) {
                 list.add(digitPair[i][0] + str + digitPair[i][1]);

Java/Validate Binary Search Tree.java

@@ -5,8 +5,11 @@
 如题, 验证是否是BST.
 
 #### DFS
-- 查看每个parent-child关系: leftchild < root < rightChild
+- 查看每个parent-child关系: leftchild < root < rightChild; 
+- BST 有两个极端: left-most-leaf is the smallest element, and right-most-leaf is largest
+- imagine we know the two extreme border: Integer.MIN_VALUE, Integer.MAX_VALUE; pass node around and compare node vs. node.parent.
 - 方法: 把root.val 传下来作为 max 或者 min, 然后检查children
+- 
 
 ##### Note: 
 - min/max需要时long type.