update the summary in topic

Author: realdennis

src/backtracking/combination.ts

@@ -1,19 +1,25 @@
-function combine(n: number, k: number): number[][] {
-    const ans: number[][] = [];
-    const partial: number[] = [];
+const combine = (n: number, k: number): number[][] => {
+    const ret: number[][] = [];
 
-    const helper = (startNum = 1): void => {
-        if (partial.length === k) {
-            ans.push([...partial]);
+    const backtracking = (start: number, prevRes: number[]): void => {
+        if (prevRes.length === k) {
+            ret.push(Array.from(prevRes));
             return;
         }
-        for (let i = startNum; i <= n; i++) {
-            partial.push(i);
-            helper(i + 1);
-            partial.pop();
+        if (start > n) {
+            return;
         }
-    };
 
-    helper();
-    return ans;
-}
+        // pick or not pick
+
+        // pick
+        prevRes.push(start);
+        backtracking(start + 1, prevRes);
+        prevRes.pop(); // resume
+
+        // not pick
+        backtracking(start + 1, prevRes);
+    };
+    backtracking(1, []);
+    return ret;
+};

src/dfs/number-of-islands.ts src/backtracking/number-of-islands.tssrc/dfs/number-of-islands.ts renamed to src/backtracking/number-of-islands.ts

@@ -5,7 +5,7 @@ function numIslands(grid: string[][]): number {
     const M = grid.length;
     const N = grid[0].length;
 
-    const dfs = (i: number, j: number): void => {
+    const backtracking = (i: number, j: number): void => {
         // boundary
         if (i < 0 || i >= M || j < 0 || j >= N) return;
 
@@ -14,18 +14,16 @@ function numIslands(grid: string[][]): number {
 
         grid[i][j] = "0";
 
-        dfs(i + 1, j);
-        dfs(i, j + 1);
-        dfs(i - 1, j);
-        dfs(i, j - 1);
+        backtracking(i + 1, j);
+        backtracking(i, j + 1);
+        backtracking(i - 1, j);
+        backtracking(i, j - 1);
     };
 
     for (let i = 0; i < M; i++) {
         for (let j = 0; j < N; j++) {
-            if (grid[i][j] === "1") {
-                dfs(i, j);
-                ret++;
-            }
+            if (grid[i][j] === "1") ret++;
+            backtracking(i, j);
         }
     }
     return ret;

src/backtracking/permutations.ts

@@ -1,18 +1,21 @@
-function permute(nums: number[]): number[][] {
+const permute = (nums: number[]): number[][] => {
+    const N = nums.length; // boundary
     const ret: number[][] = [];
-    const backtracking = (nums: number[], level: number): void => {
-        if (level === nums.length - 1) {
-            ret.push([...nums]);
+    const backtracking = (start: number): void => {
+        // for this case we update the nums, instead of preRes
+        if (start === N) {
+            ret.push(Array.from(nums)); // using Array.from to hard copy
             return;
         }
 
-        for (let i = level; i < nums.length; i++) {
-            [nums[i], nums[level]] = [nums[level], nums[i]];
-            backtracking(nums, level + 1);
-            [nums[i], nums[level]] = [nums[level], nums[i]];
+        for (let i = start; i < N; i++) {
+            // swap (i!==start) or not (i===start)
+            [nums[i], nums[start]] = [nums[start], nums[i]];
+            backtracking(start + 1);
+            [nums[i], nums[start]] = [nums[start], nums[i]];
+            // ^^ resume the change
         }
     };
-    backtracking(nums, 0);
-
+    backtracking(0);
     return ret;
-}
+};

src/backtracking/readme.md

@@ -0,0 +1,67 @@
+# Summary of Backtracking
+
+## Backtracking pattern
+
+A recursion-based pattern
+
+Sort of the permutation / combination / recursion based question, keep trying and update the state.
+
+## Impementation
+
+```typescript
+const N = input.length; // boundary
+const ret:number[] = []
+
+const backtracking = (index:number, preRes:number[]):void => {
+    if(index === N) {
+        // collect the prevResult when we touch the boundary
+        ret.push(Array.from(preRes))
+        return; 
+    }
+}
+backtracking(index, [])
+
+return ret
+```
+
+## Example
+
+77.Combinations
+```
+Input: n = 4, k = 2
+Output: [[2,4],[3,4],[2,3],[1,2],[1,3],[1,4]]
+```
+
+```typescript
+const combine = (n:number, k:number):number[][]=> {
+    const ret:number[][] = [];
+
+    const backtracking = (start:number, prevRes:number[]):void=> {
+        if(prevRes.length === k) { 
+            // satisfied length
+            ret.push(Array.from(prevRes));
+            return;
+        }
+        if(start > n) { 
+            // boundary
+            return;
+        }
+        // pick or not pick
+        // pick
+        prevRes.push(start);
+        backtracking(start+1, prevRes);
+        prevRes.pop(); // resume
+        // not pick
+        backtracking(start+1, prevRes);
+
+    }
+    backtracking(1, []);
+    return ret;
+}
+```
+
+## Thinking process
+
+While we keep doing the same things in each iteration, and there're two state, choose or not choose, and we do both, keep going foward.
+
+Since we keep going forward, so we check the boundary.

src/binary-search-tree/convert-bst-to-greater-tree.ts

@@ -0,0 +1,21 @@
+function convertBST(root: TreeNode | null): TreeNode | null {
+    const findMax = (root: TreeNode | null): TreeNode | null => {
+        if (root === null) return null;
+        while (root.left) {
+            root = root.left;
+        }
+        return root;
+    };
+    const greaterTree = (root: TreeNode | null, initialValue = 0): TreeNode | null => {
+        if (root === null) return null;
+        if (root.right !== null) {
+            root.right = greaterTree(root.right, initialValue);
+            root.val += findMax(root.right)!.val;
+        } else {
+            root.val += initialValue;
+        }
+        root.left = greaterTree(root.left, root.val);
+        return root;
+    };
+    return greaterTree(root);
+}

src/binary-search-tree/delete-node-in-bst.ts

@@ -0,0 +1,35 @@
+function deleteNode(root: TreeNode | null, key: number): TreeNode | null {
+    if (root === null) return root;
+    if (root.val === key) {
+        const { left, right } = root;
+        if (left === null) return right;
+        else if (right === null) return left;
+        let ptr = left;
+        while (ptr.right !== null) ptr = ptr.right;
+        ptr.right = right;
+        return left;
+    } else if (root.left && root.left.val === key) {
+        const { left, right } = root.left;
+        if (left === null) root.left = right;
+        else {
+            let ptr = left;
+            while (ptr.right !== null) ptr = ptr.right;
+            ptr.right = right;
+            root.left = left;
+        }
+    } else if (root.right && root.right.val === key) {
+        const { left, right } = root.right;
+        if (left === null) root.right = right;
+        else {
+            let ptr = left;
+            while (ptr.right !== null) ptr = ptr.right;
+            ptr.right = right;
+            root.right = left;
+        }
+    } else if (root.val < key) {
+        root.right = deleteNode(root.right, key);
+    } else {
+        root.left = deleteNode(root.left, key);
+    }
+    return root;
+}

src/binary-search-tree/increasing-order-binary-search-tree.ts

@@ -0,0 +1,20 @@
+function increasingBST(root: TreeNode | null): TreeNode | null {
+    // do in order traversal first
+    if (root === null) return null;
+
+    const inorder = (node: TreeNode | null): number[] => {
+        return node === null ? [] : [...inorder(node.left), node.val, ...inorder(node.right)];
+    };
+
+    const nodes = inorder(root);
+    const firstNode = nodes.shift()!;
+
+    let _root = new TreeNode(firstNode);
+    const _root_ref = _root;
+    while (nodes.length !== 0) {
+        const node = nodes.shift()!;
+        _root.right = new TreeNode(node);
+        _root = _root.right;
+    }
+    return _root_ref;
+}

src/binary-search-tree/lowest-common-ancestor-of-a-binary-search-tree.ts

@@ -0,0 +1,14 @@
+function lowestCommonAncestor(
+    root: TreeNode | null,
+    p: TreeNode | null,
+    q: TreeNode | null
+): TreeNode | null {
+    if (root === null) return null;
+    if (p!.val < root.val && q!.val < root.val) {
+        return lowestCommonAncestor(root.left, p, q);
+    }
+    if (p!.val > root.val && q!.val > root.val) {
+        return lowestCommonAncestor(root.right, p, q);
+    }
+    return root;
+}

src/binary-search-tree/minimum-distance-between-BST-nodes.ts

@@ -0,0 +1,19 @@
+function minDiffInBST(root: TreeNode | null): number {
+    let ret = Number.MAX_SAFE_INTEGER;
+    const inorder = (node: TreeNode | null): number[] => {
+        if (node === null) return [];
+
+        const left = inorder(node.left);
+        const right = inorder(node.right);
+
+        ret = Math.min(
+            ret,
+            left.length === 0 ? Number.MAX_SAFE_INTEGER : node.val - left[left.length - 1],
+            right.length === 0 ? Number.MAX_SAFE_INTEGER : right[0] - node.val
+        );
+        return [...left, node.val, ...right];
+    };
+
+    inorder(root);
+    return ret;
+}

src/binary-search-tree/readme.md

@@ -0,0 +1,23 @@
+# Summary Binary Search Tree
+
+## Recall the definition
+
+1. Each tree node n, `n.left.val` < `n.val` < `n.right.val`
+2. So all left sub-tree values should smaller than root
+3. So all right sub-tree values should bigger than root
+
+## Deal with the BST prob
+
+1. Recursion, just focus on `node` & `node.left` & `node.right`
+    - eg. `trim-a-binary-search-tree.ts`
+2. Scope the min val and max val question
+    - recursion and pass as params
+        - for `root.left`, max bound should be `root.val`
+        - for `root.right`, min bound should be `root.val`
+    - eg. `validate-binary-search-tree.ts`
+3. Inorder (LDR) traversal would be increasing sorted array
+4. Inorder traversal could be replaced to Morris traversal (space O(1)), by raising up the L tree, concat the D(root) to `rightmost` of L.
+5. Delete node `n`
+    - raise up the `n.left`
+    - Put the `n.right` to the rightmost of `n.left`
+        - if `n.left` is null, just raising up `n.right`