Add and update some graph notes and problem solving solutions

Author: enginebai

leetcode/1249.minimum-remove-to-make-valid-parentheses.md

@@ -1,4 +1,4 @@
-## [1249. Minimum Remove to Make Valid Parentheses](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)
+# [1249. Minimum Remove to Make Valid Parentheses](https://leetcode.com/problems/minimum-remove-to-make-valid-parentheses/)
 
 ## Clarification Questions
 * No, it's clear from problem description.
@@ -16,11 +16,12 @@ Input:
 Output: 
 ```
 
+## Stack
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
     if (s.isEmpty()) return ""
     val toRemoveIndexes = hashSetOf<Int>()
-    // left parentheses index
+    // index
     val stack = Stack<Int>()
     // Scan the string to find invalid right parentheses
     for (i in 0 until s.length) {
@@ -29,16 +30,14 @@ fun minRemoveToMakeValid(s: String): String {
             stack.push(i)
         } else if (c == ')') {
             if (stack.isEmpty()) { 
-                toRemoveIndexes.add(i)
+                toRemoveIndexes.add(i) // invalid right parentheses
             } else {
                 stack.pop()
             }
         }
     } 
     // Invalid left parentheses
-    while (!stack.isEmpty()) {
-        toRemoveIndexes.add(stack.pop())
-    }
+    toRemoveIndexes.addAll(stack)
 
     val answer = StringBuilder()
     for (i in 0 until s.length) {
@@ -50,9 +49,9 @@ fun minRemoveToMakeValid(s: String): String {
 ```
 
 * **Time Complexity**: `O(n)`, to iterate the string for scanning and building the result.
-* **Space Complexity**: `O(n)` for hash table and stack.
+* **Space Complexity**: `O(n)` for hash set and stack.
 
-Another solution, we can iterate the string from left to right, to remove invalid right parentheses, then iterate from right to left to remove the invalid left parentheses.
+Another solution, we can iterate the string from left to right, to remove invalid left parentheses, then iterate from right to left to remove the invalid right parentheses.
 
 ```kotlin
 fun minRemoveToMakeValid(s: String): String {
@@ -61,9 +60,9 @@ fun minRemoveToMakeValid(s: String): String {
     for (i in 0 until s.length) {
         val c = s[i]
         if (c == '(') stack.push(i)
-        else if (c == ')' && stack.isNotEmpty()) stack.pop()
+        else if (c == ')' && stack.isNotEmpty()) stack.pop() // Remove the valid pairs
     }
-    toRemove.addAll(stack)
+    toRemove.addAll(stack) // The left parentheses that are not matched
     stack.clear()
     for (i in s.length - 1 downTo 0) {
         val c = s[i]

leetcode/1254.number-of-closed-islands.md

@@ -15,8 +15,78 @@ Output:
 Input: 
 Output: 
 ```
+## Traversal From Islands
+We can traverse all the islands, and check if current island is closed. We can use DFS or BFS to traverse the grid.
 
-## Traversal
+```kotlin
+class Solution {
+    private val directions = arrayOf(
+        intArrayOf(-1, 0),
+        intArrayOf(1, 0),
+        intArrayOf(0, -1),
+        intArrayOf(0, 1)
+    )
+
+    private val visited = 2
+    fun closedIsland(grid: Array<IntArray>): Int {
+        val m = grid.size
+        val n = grid[0].size
+        var count = 0
+        for (i in 0 until m) {
+            for (j in 0 until n) {
+                if (grid[i][j] == 0) {
+                    if (dfs(grid, i, j)) count++
+                }
+            }
+        }
+        return count
+    }
+
+    private fun dfs(grid: Array<IntArray>, x: Int, y: Int): Boolean {
+        val m = grid.size
+        val n = grid[0].size
+        if (x !in 0 until m || y !in 0 until n) return false
+        if (grid[x][y] == 1) return true
+        if (grid[x][y] == visited) return true
+
+        grid[x][y] = visited
+
+        var result = true
+        directions.forEach { d ->
+            // result = result & dfs(grid, x + d[0], y + d[1]) will not work, we have to traverse all the cells and then return the result.
+            // but we can use `&&` to short-circuit the evaluation, it won't traverse all the cells of the same island.
+            result = dfs(grid, x + d[0], y + d[1]) && result
+        }
+        return result
+    }
+
+    private fun bfs(grid: Array<IntArray>, i: Int, j: Int): Boolean {
+        val m = grid.size
+        val n = grid[0].size
+        val q = ArrayDeque<Pair<Int, Int>>()
+        q.addLast(i to j)
+        var closed = true
+        while (q.isNotEmpty()) {
+            val pair = q.removeFirst()
+            val x = pair.first
+            val y = pair.second
+
+            if (x !in 0 until m || y!in 0 until n) {
+                closed = false
+                continue
+            }
+            if (grid[x][y] != 0) continue
+            grid[x][y] = visited
+            directions.forEach { d ->
+                q.addLast(x + d[0] to y + d[1])
+            }
+        }
+        return closed
+    }
+}
+```
+
+## Traversal From Boundary
 To find the closed island, we can find non-closed islands first, then find the closed islands. How can we find the non-closed islands? We can start searching from the edges of the grid, the islands which are connected to the edges are non-closed islands. We can mark them as invalid during traversal. Then we can find the closed islands by traversing the grid again.
 
 * We traversal (either DFS or BFS) from the 4 edges to search **non-closed** islands and mark the region as invalid during traversal.

leetcode/127.word-ladder.md

@@ -27,8 +27,78 @@ log:[dog,lot,cog,]
 cog:[dog,log,]
 ```
 
-* Run BFS on the graph that calculates the shortest path.
+## BFS
+Run BFS on the graph that calculates the shortest path.
 
+```kotlin
+class Solution {
+    fun ladderLength(beginWord: String, endWord: String, wordList: List<String>): Int {
+        val dict = HashSet<String>(wordList)
+        val queue = ArrayDeque<String>()
+        val visited = HashSet<String>()
+        queue.addLast(beginWord)
+        visited.add(beginWord) // Remember to add the beginWord to visited, otherwise it will be added to the queue again if it's in the wordList.
+
+        var steps = 0
+        while (queue.isNotEmpty()) {
+            val size = queue.size
+            for (i in 0 until size) {
+                val word = queue.removeFirst()
+                if (word == endWord) return steps + 1
+                val adjSet = getAdjacentStrings(word, dict)
+                adjSet.forEach { adj ->
+                    if (!visited.contains(adj)) {
+                        queue.addLast(adj)
+                        visited.add(adj)
+                    }
+                }
+            }
+            steps++
+        }
+        return 0
+    }
+
+    // Or equivalently, we check inf the node which popped from the queue.
+    queue.addLast(beginWord)
+    // visited.add(beginWord) // We don't add to visited here.
+
+    while (queue.isNotEmpty()) {
+        val size = queue.size
+        for (i in 0 until size) {
+            val word = queue.removeFirst()
+            if (visited.contains(word)) continue // We check here.
+            if (word == endWord) return steps + 1
+            
+            visited.add(word)
+            val adjSet = getAdjacentStrings(word, dict)
+            adjSet.forEach { adj ->
+                queue.addLast(adj)
+            }
+        }
+        steps++
+    }
+
+    private fun getAdjacentStrings(str: String, dict: HashSet<String>): HashSet<String> {
+        val set = HashSet<String>()
+        for (s in dict) {
+            if (getDiff(str, s) == 1) set.add(s)
+        }
+        return set
+    }
+
+    private fun getDiff(s1: String, s2: String): Int {
+        val size = minOf(s1.length, s2.length)
+        var diff = 0
+        for (i in 0 until size) {
+            if (s1[i] != s2[i]) diff++
+        }
+        return diff + abs(s1.length - s2.length)
+    }
+}
+```
+
+
+> Deprecated: It's correct but outdated. The above solution is more concise and efficient.
 ```kotlin
 fun ladderLength(beginWord: String, endWord: String, wordList: List<String>): Int {
     val visited = BooleanArray(wordList.size)

leetcode/130.surrounded-regions.md

@@ -57,12 +57,18 @@ class Solution {
         val left = dfs(board, x, y - 1, regions)
         val right = dfs(board, x, y + 1, regions)
         return up && down && left && right
+
+        var result = true
+        directions.forEach { adj -> 
+            result = result && dfs(board, x + adj[0], y + adj[1], regions)
+        }
+        return result
     }
 }
 ```
 
-### Bounary DFS
-The second approach is the reverse of the first approach. We need to find "non-closed" region first. We start from four boundaries, and find the regions we don't capture, and iterate the whole board again to capture the closed regions.
+### Bounary Traversal
+The second approach is the reverse traversal of the first approach. We need to find "non-closed" region first. We start from four boundaries, and find the regions we don't capture, and iterate the whole board again to capture the closed regions.
 
 ```kotlin
 private val directions = arrayOf(

leetcode/133.clone-graph.md

@@ -71,7 +71,9 @@ private fun clone(node: Node?): Node? {
 * **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.
+In BFS, we enqueue the neighbors to clone the neighbors of the current node, and also update the neighbors of the new node.
+
+In this approach, 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? {
@@ -95,11 +97,13 @@ fun bfs(node: Node?): Node? {
                     queue.addLast(adj)
                 } else {
                     // We have cloned the node, we just update the neighbors.
-                    oldNewMapping[old]!!.neighbors.add(oldNewMapping[adj]!!)
+                    oldNewMapping[old]!!.neighbors.add(oldNewMapping[adj])
                 }
             }
         }
     }
     return newNode
 }
-```
+```
+* **Time Complexity**: `O(n)` for BFS traversal.
+* **Space Complexity**: `O(n)` for hash table and queue.

leetcode/1367.linked-list-in-binary-tree.md

@@ -0,0 +1,58 @@
+# [1367. Linked List in Binary Tree](https://leetcode.com/problems/linked-list-in-binary-tree/description/)
+
+## Clarification Questions
+* No, it's clear from problem description.
+ 
+## Test Cases
+### Normal Cases
+```
+Input: 
+Output: 
+```
+### Edge / Corner Cases
+* The linked list or tree is empty.
+* The linked list is longer than the tree.
+list: 1 -> 2 -> 3
+tree: 
+```
+    1
+   / \
+  2   3
+```
+
+* The linked list is shorter than the tree.
+list: 1
+tree: 
+```
+    1
+   / \
+  2   3
+```
+
+# Approach
+It's similar to [572. Subtree of Another Tree](https://leetcode.com/problems/subtree-of-another-tree/), but we need to check if the linked list is a "substring" of the tree, not a subtree. (All the node in linked list have to be in the tree, but not all tree nodes have to be in the linked list.)
+
+```kotlin
+fun isSubPath(head: ListNode?, root: TreeNode?): Boolean {
+    // Slight different between `contains()`, we have to decide base on the definition of this recursive function.
+    if (head == null && root == null) return true   // Both are empty, is a subpath.
+    if (head == null || root == null) return false  // One of them is empty, is not a subpath.
+
+    // Search the linked list starting from the root node.
+    return contains(head, root) ||
+        isSubPath(head, root.left) || isSubPath(head, root.right) // Or search the linked list in the left and right subtree.
+}
+
+private fun contains(head: ListNode?, root: TreeNode?): Boolean {
+    // Tree contains empty list or we reach the end of the list, then it's a subpath.
+    if (head == null) return true
+    // It means we have reached the end of the tree, but the linked list is not found.
+    if (root == null) return false
+
+    // Keep searching the linked list in the tree.
+    return head.`val` == root.`val` && (contains(head.next, root.left) || contains(head.next, root.right))
+}
+```
+
+* **Time Complexity:** `O(N * M)`, where `N` is the number of nodes in the tree and `M` is the number of nodes in the linked list.
+* **Space Complexity:** `O(N + M)`, we have to travesal the tree `O(N)` and we check `contain()` which takes `O(M)` space in each tree node.

leetcode/150.evaluate-reverse-polish-notation.md

@@ -3,6 +3,21 @@
 ## Stack
 We always evaluate the result of the last two operands with the operator `A, B, opeator`, that is `A operator B`. We can use a stack to store the operands and evaluate the result.
 
+```js
+(A) (B) operator
+A = (a) (b) operator or `a` // A could be a number or a result
+B = (c) (d) operator or `b`
+
+// Example 1
+(1 2 +) (2 3 *) -
+(3) (6) -
+ 3 - 6 = -3
+
+// Example 2
+(3) (2 3 *) +
+3 + 6 = 9
+```
+
 ```kotlin
 fun evalRPN(tokens: Array<String>): Int {
     val stack = Stack<String>()