update

Author: tiationg-kho

README.md

@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public List<Integer> rightSideView(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        
+        ArrayDeque<TreeNode> queue = new ArrayDeque<>();
+
+        if (root != null) {
+            queue.offer(root);
+        }
+
+        while (!queue.isEmpty()) {
+            int levelCount = queue.size();
+            for (int i = 0; i < levelCount; i++) {
+                TreeNode node = queue.poll();
+                if (i == levelCount - 1) {
+                    res.add(node.val);
+                }
+                for (TreeNode child: new TreeNode[]{node.left, node.right}) {
+                    if (child != null) {
+                        queue.offer(child);
+                    }
+                }
+            }
+        }
+        return res;
+    }
+}
+
+// time O(n), due to traverse
+// space O(n)
+// using tree and bfs

[A]tree/[A]tree-bfs/199-binary-tree-right-side-view.java

@@ -23,5 +23,5 @@ def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
         return res
 
 # time O(n), due to traverse
-# space O(n), due to queue's size (tree diameter or last level)
+# space O(n)
 # using tree and bfs

[A]tree/[A]tree-bfs/199-binary-tree-right-side-view.py

@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode() {}
+ *     TreeNode(int val) { this.val = val; }
+ *     TreeNode(int val, TreeNode left, TreeNode right) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        Map<Integer, Integer> inValToInIdx = new HashMap<>();
+        for (int i = 0; i < inorder.length; i++) {
+            inValToInIdx.put(inorder[i], i);
+        }
+        return build(preorder, inValToInIdx, 0, preorder.length - 1, 0, inorder.length - 1, preorder.length);
+    }
+
+    public TreeNode build(int[] preorder, Map<Integer, Integer> inValToInIdx, int preLeft, int preRight, int inLeft, int inRight, int length) {
+        if (length < 1) {
+            return null;
+        }
+        TreeNode node = new TreeNode(preorder[preLeft]);
+        Integer inIdx = inValToInIdx.get(preorder[preLeft]);
+        int leftLength = inIdx - inLeft;
+        int rightLength = length - leftLength - 1;
+        node.left = build(preorder, inValToInIdx, preLeft + 1, preLeft + leftLength, inLeft, inIdx - 1, leftLength);
+        node.right = build(preorder, inValToInIdx, preLeft + leftLength + 1, preRight, inIdx + 1, inRight, rightLength);
+        return node;
+    }
+}
+
+// time O(n), due to O(1) find in hashmap but recursion n times
+// space O(n), due to hashmap or building tree or recursion
+// using tree and divide and conquer and re-build tree (top-down)
+/*
+preorder: first value is root
+inorder: every value before root is left subtree, after root is right subtree
+*/

[A]tree/[A]tree-divide-and-conquer/105-construct-binary-tree-from-preorder-and-inorder-traversal.java

@@ -0,0 +1,38 @@
+class Solution {
+    public String longestPalindrome(String s) {
+        int resLen = 1;
+        int resIdx = 0;
+
+        for (int i = 0; i < s.length(); i++) {
+            int[] cur = valid(s, i, i);
+            if (cur[1] > resLen) {
+                resIdx = cur[0];
+                resLen = cur[1];
+            }
+            cur = valid(s, i, i + 1);
+            if (cur[1] > resLen) {
+                resIdx = cur[0];
+                resLen = cur[1];
+            }
+    }
+        return s.substring(resIdx, resIdx + resLen);
+    }
+
+    public int[] valid(String s, int left, int right) {
+        int[] res = new int[]{left, 1};
+        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
+            res[0] = left;
+            res[1] = right - left + 1;
+            left -= 1;
+            right += 1;
+        }
+        return res;
+    }
+}
+
+// time O(n**2), traversal costs O(n), and each time need to using two pointers to expand
+// space O(1)
+// using array and two pointers opposite direction and expand type
+/*
+1. this is not optimal solution
+*/

[H]array/[H]array-two-pointers-opposite-direction/5-longest-palindromic-substring.java

@@ -32,4 +32,7 @@ def longestPalindrome(self, s: str) -> str:
 
 # time O(n**2), traversal costs O(n), and each time need to using two pointers to expand
 # space O(1)
-# using array and two pointers opposite direction and expand type
+# using array and two pointers opposite direction and expand type
+'''
+1. this is not optimal solution
+'''

[H]array/[H]array-two-pointers-opposite-direction/5-longest-palindromic-substring.py

@@ -0,0 +1,37 @@
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        dfs(res, nums, new ArrayList<>(), 0);
+        return res;
+    }
+
+    public void dfs(List<List<Integer>> res, int[] nums, List<Integer> path, int idx) {
+        if (idx == nums.length) {
+            res.add(new ArrayList<>(path));
+            return;
+        }
+
+        dfs(res, nums, path, idx + 1);
+
+        path.add(nums[idx]);
+        dfs(res, nums, path, idx + 1);
+        path.remove(path.size() - 1);
+        return;
+    }
+}
+
+// time O(n*(2**n)), due to each element can take or not take (2**n), and n for copy list
+// space O(n), due to recursion stack, not counting output here
+// using dfs and backtracking and subset
+/*
+1. type: subset
+2. duplicate elements: no
+3. selectable repeatedly: no
+*/
+/*
+this approach focus on considering each element:
+for cur element, 
+we don't take, then goto next element
+or we take, then goto next element
+till no more element to be considered, we record path
+*/

[J]backtracking/[J]backtracking/78-subsets.java

@@ -0,0 +1,24 @@
+class Solution {
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m][n];
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == 0 && j == 0) {
+                    dp[i][j] = 1;
+                } else if (i == 0) {
+                    dp[i][j] = dp[i][j - 1];
+                } else if (j == 0) {
+                    dp[i][j] = dp[i - 1][j];
+                } else {
+                    dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
+                }
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}
+
+// time O(nm), due to grids' size
+// space O(nm), due to list
+// using dynamic programming and 2D