Add new problem notes and update some problem notes

Author: enginebai

Algorithms.code-workspace

@@ -2,10 +2,6 @@
 	"folders": [
 		{
 			"path": "."
-		},
-		{
-			"name": ".leetcode",
-			"path": "../../../.leetcode"
 		}
 	],
 	"settings": {}

leetcode/100.same-tree.md

@@ -50,7 +50,33 @@ fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
 }
 ```
 
-* **Time Complexity**: `O(min(P, Q)`, where `P` and `Q` are the number of tree nodes of `p` and `q`.
+* **Time Complexity**: `O(min(P, Q))`, where `P` and `Q` are the number of tree nodes of `p` and `q`.
+* **Space Complexity**: `O(min(P, Q))`
+
+## Iterative
+```kotlin
+fun isSameTree(p: TreeNode?, q: TreeNode?): Boolean {
+    val pQueue = ArrayDeque<TreeNode?>()
+    val qQueue = ArrayDeque<TreeNode?>()
+    pQueue.addLast(p)
+    qQueue.addLast(q)
+    while (pQueue.isNotEmpty() && qQueue.isNotEmpty()) {
+        val pp = pQueue.removeFirst()
+        val qq = qQueue.removeFirst()
+
+        if (pp == null && qq == null) continue
+        if (pp == null || qq == null) return false
+        if (pp.`val` != qq.`val`) return false
+        pQueue.addLast(pp.left)
+        qQueue.addLast(qq.left)
+
+        pQueue.addLast(pp.right)
+        qQueue.addLast(qq.right)
+    }
+    return pQueue.isEmpty() && qQueue.isEmpty()
+}
+```
+* **Time Complexity**: `O(min(P, Q))`, where `P` and `Q` are the number of tree nodes of `p` and `q`.
 * **Space Complexity**: `O(min(P, Q))`
 
 ## Traversal

leetcode/101.symmetric-tree.md

@@ -46,6 +46,9 @@ fun check(left: TreeNode?, right: TreeNode?): Boolean {
 }
 ```
 
+* **Time Complexity**: `O(n)`, where `n` is the number of tree nodes.
+* **Space Complexity**: `O(h)`, where `h` is the height of the tree.
+
 ## Iterative
 ```kotlin
 fun isSymmetric(root: TreeNode?): Boolean {
@@ -74,4 +77,6 @@ fun isSymmetric(root: TreeNode?): Boolean {
 
     return leftQueue.isEmpty() && rightQueue.isEmpty()
 }
-```
+```
+* **Time Complexity**: `O(n)`, where `n` is the number of tree nodes.
+* **Space Complexity**: `O(n)`, where `n` is the number of tree nodes.

leetcode/110.balanced-binary-tree.md

@@ -84,7 +84,7 @@ private fun getHeight(node: TreeNode?): Int {
 ### Bottom-Up Solution (Optimal)
 From previous solution, we invoke `isBalanced()` for each node recursively, and for each `isBalanced()` we have to calculate the height `getHeight()` recursively which leads to `O(n^2)` time complexity. Here we can optimize the solution by changing (merging) the purpose of `getHeight()`. We still use `getHeight()` to calculate the height, and use this function to indicate if the subtree is height-balanced at the same time.
 * If it's height-balanced, then return the height of current subtree.
-* Otherwise, just return -1 to indicate unbalanced. If it's not balanced from its child node, then the current node is not balanced as well.
+* Otherwise, just return `-1` to indicate unbalanced. If it's not balanced from its child node, then the current node is not balanced as well.
 
 ![](../media/110.balanced-binary-tree.png)
 > Source: [Solution](https://leetcode.cn/problems/balanced-binary-tree/solution/ping-heng-er-cha-shu-by-leetcode-solution/)

leetcode/111.minimum-depth-of-binary-tree.md

@@ -90,6 +90,8 @@ fun minDepth(root: TreeNode?): Int {
     else return 1 + minOf(minDepth(root.left), minDepth(root.right))
 }
 ```
+* **Time Complexity**: `O(n)`, iterate all nodes.
+* **Space Complexity**: `O(n)`, the worst case is the tree is a linked list, so the recursion stack will store all nodes.
 
 ## BFS
 We traversal level by level, and search the first leaf node, then return the depth.

leetcode/1110.delete-nodes-and-return-forest.md

@@ -0,0 +1,88 @@
+# [1110. Delete Nodes And Return Forest](https://leetcode.com/problems/delete-nodes-and-return-forest/)
+
+## Clarification Questions
+* Does the `to_delete` array contain the node that does not exist in the tree?
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+        1               
+     /     \      
+    3       5          
+  /   \    / \
+ 8    9   7   0   
+         /   / 
+        2   6   
+delete = [5]
+Output: 
+        1               
+     /          
+    3                 
+  /   \    
+ 8    9   7   0   
+         /   / 
+        2   6  
+```
+### Edge / Corner Cases
+* The nodes to delete are in the same subtree.
+```
+Input: 
+        1               
+     /     \      
+    3       5          
+  /   \    / \
+ 8    9   7   0   
+         /   / 
+        2   6  
+delete = [1,5]
+Output: 
+    3               
+  /   \    
+ 8    9   7   0   
+         /   / 
+        2   6  
+```
+
+## Postorder 
+**Idea!!** We can traverse the tree, if the current node is in the delete list, we can add its children to the forest.
+
+```js
+        1       del(1)
+     /     \
+    2       3
+  ...       ...
+
+// After delete `1`, the subtrees `2` and `3` become the forest.
+     /     \
+    2       3
+  ...       ...
+```
+We use postorder to delete, because we need to delete the nodes from the bottom to the top. Here is one key point to note, if the original root is not in the delete list, we should add it to the forest first.
+```kotlin
+fun delNodes(root: TreeNode?, to_delete: IntArray): List<TreeNode?> {
+    val set = HashSet<Int>()
+    for (d in to_delete) set.add(d)
+    val forest = mutableListOf<TreeNode?>()
+    // If the root is not in the delete list, add it to the forest first.
+    if (!set.contains(root?.`val`)) forest.add(root)
+    delete(root, set, forest)
+    return forest
+}
+
+private fun delete(root: TreeNode?, deleteSet: HashSet<Int>, forest: MutableList<TreeNode?>): TreeNode? {
+    if (root == null) return null
+
+    root.left = delete(root.left, deleteSet, forest)
+    root.right = delete(root.right, deleteSet, forest)
+    if (deleteSet.contains(root.`val`)) {
+        if (root.left != null) forest.add(root.left)
+        if (root.right != null) forest.add(root.right)
+        return null
+    }
+    return root
+}
+```
+
+* **Time Complexity:** `O(n)`
+* **Space Complexity:** `O(n)`

leetcode/114.flatten-binary-tree-to-linked-list.md

@@ -139,7 +139,7 @@ private fun subtreeLast(root: TreeNode): TreeNode {
 * **Time Complexity**: `O(n)`, where `n` is the node of tree.
 * **Space Complexity**: `O(h)`, where `h` is the height of tree.
 
-## DFS
+## Postorder (DFS)
 We can use postorder traversal to flatten the tree. The idea is to flatten the left subtree and right subtree first, then we relink the right subtree after the right most node of left subtree.
 
 ![](../media/114.flatten-binary-tree-to-linked-list.png)
@@ -170,7 +170,7 @@ private fun subtreeLast(node: TreeNode?): TreeNode? {
 }
 ```
 
-## DFS with Pointers (Constant Space Complexity)
+## Postorder with Pointers (Space Optimization)
 Idea is the same, but we traversal with pointers only (removing stack or recursion).
 
 ```kotlin

leetcode/121.best-time-to-buy-and-sell-stock.md

@@ -5,11 +5,11 @@ We're going to find minimium price to buy and calculate max profit for every day
 
 ```kotlin
 fun maxProfit(prices: IntArray): Int {
-    var lowestPrice = prices[0]
+    var lowestPrice = Int.MAX_VALUE
     var maxProfit = 0
-    for (i in 1 until prices.size) {
-        lowestPrice = min(lowestPrice, prices[i])
-        maxProfit = max(maxProfit, prices[i] - lowestPrice)
+    for (i in 0 until prices.size) {
+        lowestPrice = minOf(lowestPrice, prices[i])
+        maxProfit = maxOf(maxProfit, prices[i] - lowestPrice)
     }
     return maxProfit
 }

leetcode/133.clone-graph.md

@@ -0,0 +1,105 @@
+# [133. Clone Graph](https://leetcode.com/problems/clone-graph/description/)
+
+## DFS + Hash Table
+We can use DFS or BFS to traverse from starting node to clone the node, then store the old and new node mapping in hash table, and update the neighbors of the new node by traversing the neighbors of the old node.
+
+```kotlin
+/**
+ * Definition for a Node.
+ * class Node(var `val`: Int) {
+ *     var neighbors: ArrayList<Node?> = ArrayList<Node?>()
+ * }
+ */
+
+class Solution {
+
+    // 1: 1'
+    // 2: 2'
+    private val oldNewMapping = HashMap<Node, Node>()
+
+    fun cloneGraph(node: Node?): Node? {
+        cloneNode(node)
+        updateNeighbors(node, HashSet<Node>())
+        return oldNewMapping[node]
+    }
+
+    private fun cloneNode(node: Node?) {
+        if (node == null || oldNewMapping.containsKey(node)) return
+        val newNode = Node(node.`val`)
+        oldNewMapping[node] = newNode
+        node.neighbors.forEach { adj -> 
+            cloneNode(adj)
+        }
+    }
+
+    // 1 -> 1'
+    // 1: [2, 3] -> 1': [2', 3']
+    private fun updateNeighbors(node: Node?, updated: HashSet<Node>) {
+        if (node == null || updated.contains(node)) return
+        val newNode = oldNewMapping[node]
+        if (newNode != null) {
+            node.neighbors.forEach { adj -> 
+                val newAdj = oldNewMapping[adj]
+                newNode.neighbors.add(newAdj)
+            }
+        }
+        updated.add(node)
+        node.neighbors.forEach { adj -> 
+            updateNeighbors(adj, updated)
+        }
+    }    
+}
+
+// Or equivalently, we can update the neighbors during the DFS traversal.
+
+fun cloneGraph(node: Node?): Node? {
+    return clone(node)
+}
+
+private fun clone(node: Node?): Node? {
+    if (node == null) return null
+    if (oldNewMapping.containsKey(node)) return oldNewMapping[node]!!
+    val newNode = Node(node.`val`)
+    oldNewMapping[node] = newNode
+    node.neighbors.forEach { adj ->
+        newNode.neighbors.add(clone(adj))
+    }
+    return newNode
+}
+```
+* **Time Complexity**: `O(n)` for DFS traversal.
+* **Space Complexity**: `O(n)` for hash table and recursion stack.
+
+## BFS + Hash Table
+In BFS, we still need old and new node mapping to prevent duplicate visited. We have to update the neighbors of current node when we traverse the neighbors of the old node.
+
+```kotlin
+fun bfs(node: Node?): Node? {
+    if (node == null) return null
+    val queue = ArrayDeque<Node>()
+    queue.addLast(node)
+    val newNode = Node(node.`val`)
+    oldNewMapping[node] = newNode
+
+    while (queue.isNotEmpty()) {
+        val old = queue.removeFirst()
+
+        // We don't clone here, we clone and update the neighbors when we visit the adjacent nodes.
+
+        old.neighbors.forEach { adj -> 
+            if (adj != null) {
+                if (!oldNewMapping.containsKey(adj)) {
+                    val newNode = Node(adj.`val`)
+                    oldNewMapping[adj] = newNode
+                    oldNewMapping[old]!!.neighbors.add(newNode)
+                    queue.addLast(adj)
+                } else {
+                    // We have cloned the node, we just update the neighbors.
+                    oldNewMapping[old]!!.neighbors.add(oldNewMapping[adj]!!)
+                }
+            }
+        }
+    }
+    return newNode
+}
+```

leetcode/1382.balance-a-binary-search-tree.md

@@ -0,0 +1,33 @@
+# [1382. Balance a Binary Search Tree](https://leetcode.com/problems/balance-a-binary-search-tree/description/)
+
+### Inorder
+We can build the inorder traversal of the tree and then build a new tree from the inorder traversal.
+
+```kotlin
+private val list = mutableListOf<TreeNode>()
+
+fun balanceBST(root: TreeNode?): TreeNode? {
+    if (root == null) return null
+    inorder(root)
+    return build(0, list.size - 1)        
+}
+
+private fun inorder(root: TreeNode?) {
+    if (root == null) return
+    inorder(root.left)
+    list.add(root)
+    inorder(root.right)
+}
+
+private fun build(start: Int, end: Int): TreeNode? {
+    if (start > end) return null
+    val middle = start + (end - start) / 2
+    val newRoot = list[middle]
+    newRoot.left = build(start, middle - 1)
+    newRoot.right = build(middle + 1, end)
+    return newRoot
+}
+```
+
+* Time Complexity: `O(n)`
+* Space Complexity: `O(n)`