Update notes and problems

Author: enginebai

leetcode/108.convert-sorted-array-to-binary-search-tree.md

@@ -1,21 +1,5 @@
 ## [108. Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/)
 
-## Clarification Questions
-* No, it's clear from problem description.
- 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
-
 ### Subarray
 ```kotlin
 fun sortedArrayToBST(nums: IntArray): TreeNode? {

leetcode/1129.shortest-path-with-alternating-colors.md

@@ -65,6 +65,10 @@ fun shortestAlternatingPaths(n: Int, redEdges: Array<IntArray>, blueEdges: Array
     // Regular BFS to update the shortest distance
     while (queue.isNotEmpty()) {
         val node = queue.removeFirst()
+        val current = node.index
+        val isRed = node.isRed
+        val distance = node.distance
+
         // We update the distance for every node when visiting the particular node
         distances[current] = minOf(distances[current], distance)
 

leetcode/1146.snapshot-array.md

@@ -47,6 +47,8 @@ get(snapId=1) = 1
 get(snapId=2) = 1
 ```
 
+> 接下来我们需要考虑一个效率的问题。我们每调用一次snap()是否需要给每个元素都新建一次快照呢？显然如果大多数元素都没有更新过的话，再添加一次快照的效率不高。所以我们可以设置一个changed的集合，里面只存放上一次snap()之后变动过的元素，也就是被set()过的元素。 我们会发现对于每个元素而言，它被记录的snapId并不是连续的。所以我们应该在snaps[index]里面找到最后一个小于等于snapId的那个时间戳。
+
 ## Brute Force (MLE)
 We just save all snapshots. It wastes memory if we have a large array but only a few elements are modified.
 

leetcode/1162.as-far-from-land-as-possible.md

@@ -1,29 +1,11 @@
 ## [1162. As Far from Land as Possible](https://leetcode.com/problems/as-far-from-land-as-possible/)
 
-## Clarification Questions
-* No, it's clear from problem description.
- 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
+> TODO: Review the notes + implementations
 
-```kotlin
-val directions = arrayOf(
-    intArrayOf(-1, 0),
-    intArrayOf(1, 0),
-    intArrayOf(0, -1),
-    intArrayOf(0, 1)
-)
+### BFS
+The problem is looking for the farest water cell from the nearest land cell. We can start from the land cells and traverse the water cells to find the farest distance.
 
+```kotlin
 fun maxDistance(grid: Array<IntArray>): Int {
     val n = grid.size
     var maxDistance = 0

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

@@ -1,125 +1,156 @@
 # [1254. Number of Closed Islands](https://leetcode.com/problems/number-of-closed-islands/)
 
 ## 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.
+We can traverse all the islands, and check if current island is closed. We can use DFS or BFS to traverse the grid. Remember! We have to traverse all the cells of the island to check if it's closed even if we found a cell that is not closed.
 
 ```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++
-                }
+fun closedIsland(grid: Array<IntArray>): Int {
+    val m = grid.size
+    val n = grid[0].size
+    val visited = HashSet<Pair<Int, Int>>()
+    var count = 0
+    for (i in 0 until m) {
+        for (j in 0 until n) {
+            if (grid[i][j] == 0 && visited.contains(i to j).not()) {
+                if (dfs(grid, i, j, visited)) count++
+                // if (bfs(grid, i, j, visited)) count++
             }
         }
-        return 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
+private fun dfs(grid: Array<IntArray>, x: Int, y: Int, visited: HashSet<Pair<Int, Int>>): Boolean {
+    val m = grid.size
+    val n = grid[0].size
+    visited.add(x to y)
+    var result = true
+    for (d in directions) {
+        val newX = x + d[0]
+        val newY = y + d[1]
+        if (newX !in 0 until m || newY !in 0 until n) result = false    // Out of boundary, it affects the result.
+        else if (visited.contains(newX to newY)) continue               // Skip, don't change the result
+        else if (grid[newX][newY] == 1) continue                        // We initialize the result as true, we keep it true (won't change it) untili we reach the boundary.
+        else result = dfs(grid, newX, newY, visited) && result
+    }
+    return result
+}
 
-        grid[x][y] = visited
+private fun dfs(grid: Array<IntArray>, x: Int, y: Int, visited: HashSet<Pair<Int, 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 (visited.contains(x to y)) return true
+    if (grid[x][y] == 1) return true
 
-        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 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
+    visited.add(x to y)
+    var result = true
+    for (d in directions) {
+        val newX = x + d[0]
+        val newY = y + d[1]
+        // 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 use `&&` to short-circuit the evaluation, it won't traverse all the cells of the same island.
+        result = dfs(grid, newX, newY, visited) && 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
+private fun bfs(grid: Array<IntArray>, sourceX: Int, sourceY: Int, visited: HashSet<Pair<Int, Int>>): Boolean {
+    val m = grid.size
+    val n = grid[0].size
+    val queue = ArrayDeque<Pair<Int, Int>>()
+    queue.addLast(sourceX to sourceY)
+    visited.add(sourceX to sourceY)
+    var result = true
+    while (queue.isNotEmpty()) {
+        val (x, y) = queue.removeFirst()
+        for (d in directions) {
+            val newX = x + d[0]
+            val newY = y + d[1]
+            if (newX !in 0 until m || newY !in 0 until n) result = false
+            else if (visited.contains(newX to newY)) continue
+            else if (grid[newX][newY] == 1) continue
+            else {
+                queue.addLast(newX to newY)
+                visited.add(newX to newY)
             }
-            if (grid[x][y] != 0) continue
-            grid[x][y] = visited
-            directions.forEach { d ->
-                q.addLast(x + d[0] to y + d[1])
+        }
+    }
+    return result
+}
+
+private fun bfs(grid: Array<IntArray>, sourceX: Int, sourceY: Int, visited: HashSet<Pair<Int, Int>>): Boolean {
+    val m = grid.size
+    val n = grid[0].size
+    val queue = ArrayDeque<Pair<Int, Int>>()
+    queue.addLast(sourceX to sourceY)
+    var result = true
+    while (queue.isNotEmpty()) {
+        val (x, y) = queue.removeFirst()
+        if (x !in 0 until m || y !in 0 until n) result = false
+        else if (visited.contains(x to y)) continue
+        else if (grid[x][y] == 1) continue
+        else {
+            visited.add(x to y)
+            for (d in directions) {
+                val newX = x + d[0]
+                val newY = y + d[1]
+                queue.addLast(newX to newY)
             }
         }
-        return closed
     }
+    return result
 }
 ```
 
 ## 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.
+To find the closed island, we can find open islands first, then find the 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.
 * Then we traversal the graph again to find `0`, that would be closed islands.
 
 ```kotlin
-class Solution {
-    private val invalid = 2
-    private val directions = arrayOf(
-        -1 to 0, 1 to 0, 0 to -1, 0 to 1)
+private val invalid = 2
+
+fun closedIsland(grid: Array<IntArray>): Int {
+    val m = grid.size
+    val n = grid[0].size
 
-    fun closedIsland(grid: Array<IntArray>): Int {
-        val m = grid.size
-        val n = grid[0].size
-        
-        for (row in 0 until m) {
-            dfs(grid, row, 0)
-            dfs(grid, row, n - 1)
-        }
-        
-        for (col in 0 until n) {
-            dfs(grid, 0, col)
-            dfs(grid, m - 1, col)
-        }
-        
-        var count = 0
-        for (row in 0 until m) {
-            for (col in 0 until n) {
-                if (grid[row][col] == 0) {
-                    dfs(grid, row, col)
-                    count++
-                }
-            }
-        }
-        return count
+    for (row in 0 until m) {
+        dfs(grid, row, 0)
+        dfs(grid, row, n - 1)
+    }
+    
+    for (col in 0 until n) {
+        dfs(grid, 0, col)
+        dfs(grid, m - 1, col)
     }
 
-    private fun dfs(grid: Array<IntArray>, x: Int, y: Int) {
-        if (x in 0 until grid.size &&
-                y in 0 until grid[0].size &&
-                grid[x][y] == 0) {
-            grid[x][y] = invalid
-            
-            directions.forEach {
-                dfs(grid, x + it.first, y + it.second)
+    var count = 0
+    for (row in 0 until m) {
+        for (col in 0 until n) {
+            if (grid[row][col] == 0) {
+                dfs(grid, row, col)
+                count++
             }
         }
     }
+    return count
+}
+
+private fun dfs(grid: Array<IntArray>, x: Int, y: Int) {
+    val m = grid.size
+    val n = grid[0].size
+    if (x !in 0 until m || y !in 0 until n) return
+    if (visited.contains(x to y)) return
+    if (grid[x][y] == 1) return
+
+    grid[x][y] = invalid
+    for (d in directions) {
+        val newX = x + d[0]
+        val newY = y + d[1]
+        dfs(grid, newX, newY)
+    }
 }
 ```