Add solutions to new graph problems

Author: enginebai

README.md

@@ -22,7 +22,7 @@ This project offers a curated collection of notes and resources covering fundame
     - [Binary Search Tree](./problems/bst-problems.md)
 - [Heap & Priority Queue](./topics/heap.md) ([Problems](./problems/heap-problems.md))
 - [Graph](./topics/graph.md) ([Problems](./problems/graph-problems.md))
-- [Shortest Path](./topics/shortest-path.md)
+- [Shortest Path](./topics/shortest-path.md) ([Problems](./problems/shortest-path-problems.md))
 - [Recursion](./topics/recursion.md)
 - [Dynamic Programming](./topics/dynamic-programming.md) ([Problems](./problems/dynamic-programming-problems.md))
 - [Greedy](./topics/greedy.md) ([Problems](./problems/greedy-problems.md))

leetcode/1042.flower-planting-with-no-adjacent.md

@@ -0,0 +1,38 @@
+# [1042. Flower Planting With No Adjacent](https://leetcode.com/problems/flower-planting-with-no-adjacent/)
+
+```kotlin
+fun gardenNoAdj(n: Int, paths: Array<IntArray>): IntArray {
+    val graph = buildGraph(n, paths)
+    val answer = IntArray(n)
+    for (i in 0 until n) {
+        if (answer[i] == 0) {
+            dfs(graph, i, answer)
+        }
+    }
+    return answer
+}
+
+private fun dfs(graph: Array<HashSet<Int>>, i: Int, answer: IntArray) {
+    if (answer[i] != 0) return
+
+    val types = (1..4).toHashSet()
+    for (adj in graph[i]) {
+        val adjType = answer[adj]
+        types.remove(adjType)
+    }
+    answer[i] = types.first()
+    graph[i].forEach { adj ->
+        dfs(graph, adj, answer)
+    }
+}
+
+private fun buildGraph(n: Int, paths: Array<IntArray>): Array<HashSet<Int>> {
+    val graph = Array(n) { HashSet<Int>() }
+    for ((x, y) in paths) {
+        // Minus 1 for 0-indexed
+        graph[x - 1].add(y - 1)
+        graph[y - 1].add(x - 1)
+    }
+    return graph
+}
+```

leetcode/1091.shortest-path-in-binary-matrix.md

@@ -1,57 +1,45 @@
-## [1091. Shortest Path in Binary Matrix](https://leetcode.com/problems/shortest-path-in-binary-matrix/)
-
-## Clarification Questions
-* No, it's clear from problem description.
- 
-## Test Cases
-### Normal Cases
-```
-Input: 
-Output: 
-```
-### Edge / Corner Cases
-* 
-```
-Input: 
-Output: 
-```
+# [1091. Shortest Path in Binary Matrix](https://leetcode.com/problems/shortest-path-in-binary-matrix/)
 
+## BFS
 ```kotlin
 private val directions = arrayOf(
-            intArrayOf(-1, -1),
-            intArrayOf(-1, 0),
-            intArrayOf(-1, 1),
-            intArrayOf(0, -1),
-            intArrayOf(0, 1),
-            intArrayOf(1, -1),
-            intArrayOf(1, 0),
-            intArrayOf(1, 1)
-        )
+    intArrayOf(-1, -1),
+    intArrayOf(-1, 0),
+    intArrayOf(-1, 1),
+    intArrayOf(0, -1),
+    intArrayOf(0, 1),
+    intArrayOf(1, -1),
+    intArrayOf(1, 0),
+    intArrayOf(1, 1)
+)
 
 fun shortestPathBinaryMatrix(grid: Array<IntArray>): Int {
     val n = grid.size
     if (grid[0][0] == 1 || grid[n - 1][n - 1] == 1) return -1
-    
-    val distances = Array(n) { _ -> IntArray(n) { _ -> Int.MAX_VALUE }}
+
+    var distance = 1
     val queue = ArrayDeque<Pair<Int, Int>>()
-    queue.add(0 to 0)
-    distances[0][0] = 1
-    while (!queue.isEmpty()) {
-        val node = queue.removeFirst()
-        val x = node.first
-        val y = node.second
-        if (x == n - 1 && y == n - 1) return distances[x][y]
-        directions.forEach { d ->
-            val newX = x + d[0]
-            val newY = y + d[1]
-            val distance = distances[x][y] + 1
-            if (newX in 0 until grid.size && newY in 0 until grid.size && grid[newX][newY] == 0) {
-                if (distances[newX][newY] > distance) {
-                    distances[newX][newY] = distance
+    val visited = HashSet<Pair<Int, Int>>()
+    queue.addLast(0 to 0)
+    visited.add(0 to 0)
+    while (queue.isNotEmpty()) {
+        val size = queue.size
+        repeat (size) {
+            val (x, y) = queue.removeFirst()
+            if (x == n - 1 && y == n - 1) return distance
+            for (d in directions) {
+                val newX = x + d[0]
+                val newY = y + d[1]
+                if (newX !in 0 until n) continue
+                if (newY !in 0 until n) continue
+                if (visited.contains(newX to newY)) continue
+                if (grid[newX][newY] == 0) {
                     queue.addLast(newX to newY)
+                    visited.add(newX to newY)
                 }
             }
         }
+        distance++
     }
     return -1
 }

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

@@ -1,34 +1,45 @@
 # [1129. Shortest Path with Alternating Colors](https://leetcode.com/problems/shortest-path-with-alternating-colors/)
 
+## Hints
+- What if you ignore the color alternation? How would you find the shortest path?
+- How can you represent the state so that you don't revisit the same node with the same previous color?
+- Why do you need to track the color of the previous edge in your BFS state?
+
 ## Breakdowns
-> 1. How to calculate the shortest path from 0 to `i`?
+> 1. How to calculate the shortest path from `0` to `i`?
+
+Start BFS from `0`, and maintain a distance array for each node.
 
-Start BFS from 0, and maintain the distance array.
+> 2. How to know the color of the edge for node `i`?
 
-> 2. How to know the color of edge of node `i`?
-Convert it to an adjacency list, so that we can get the color of the edge at `i`.
+Convert the edge lists to two adjacency lists: one for red edges, one for blue edges.
 ```js
 var red[i] = set(...)
 var blue[i] = set(...)
 ```
 
 > 3. How to alternate color along the path?
 
-We have to record the current color along th path.
-
+Record the color of the previous edge in the BFS state, and only traverse edges of the opposite color next.
 ```js
 node.color = !node.color
 ```
 
 > 4. How to know there is no such path?
 
-Initialize the distance as `inf`, then it is impossible if it remains `inf` after traverse.
+Initialize the distance as `inf` (or `Int.MAX_VALUE`), then if it remains `inf` after traversal, it is unreachable.
+
+## BFS with Color State
+- This is a classic BFS shortest path problem, but with an extra state: the color of the previous edge.
+- The key is to treat `(node, previous color)` as the BFS state, because you can revisit the same node if you arrive via a different color.
+- You need two visited arrays (or a 2D visited array): one for red, one for blue, to avoid revisiting the same node with the same color.
+- This pattern is similar to other BFS problems with extra state, such as [1293. Shortest Path in a Grid with Obstacles Elimination](1293.shortest-path-in-a-grid-with-obstacles-elimination.md), where the state includes remaining eliminations.
+- BFS guarantees the shortest path is found first for each state.
 
-## BFS
 ```kotlin
 data class MyNode(
     val index: Int,
-    val isRed: Boolean,
+    val isRed: Boolean, // true if the previous edge is red, false if blue
     val distance: Int
 )
 
@@ -47,7 +58,7 @@ fun shortestAlternatingPaths(n: Int, redEdges: Array<IntArray>, blueEdges: Array
     val blueVisited = BooleanArray(n)
 
     // Start from 0, and add the red and blue edges to the queue
-    ueue.addLast(MyNode(0, true, 0))
+    queue.addLast(MyNode(0, true, 0))
     queue.addLast(MyNode(0, false, 0))
     redVisited[0] = true
     blueVisited[0] = true
@@ -109,5 +120,27 @@ private fun convert(n: Int, edges: Array<IntArray>): Array<HashSet<Int>> {
 }
 ```
 
-* **Time Complexity:** `O(N + Red + Blue)`
-* **Space Complexity:** `O(N + Red + Blue)`
+- **Time Complexity**: `O(N + Red + Blue)`, where `N` is the number of nodes, and `Red`/`Blue` are the number of red/blue edges.
+- **Space Complexity**: `O(N + Red + Blue)` for adjacency lists and visited arrays.
+
+## Edge Cases
+- If there are no outgoing edges from `0`, all other nodes are unreachable.
+- If a node can only be reached by two consecutive edges of the same color, it is unreachable.
+- Self-loops and parallel edges: the algorithm handles them naturally, as long as you track visited by color.
+- If the graph is disconnected, unreachable nodes should return `-1`.
+
+## Pitfalls
+- Forgetting to track visited status separately for red and blue arrivals can lead to infinite loops or incorrect answers.
+- Not alternating colors correctly when traversing edges.
+- Updating the distance for a node without considering the color state can cause wrong results.
+- **Mistake**: Using a single visited array for all states (should be per color).
+- **Mistake**: Not initializing both red and blue starts from node `0`.
+
+## Similar or Follow-up Problems
+- [1293. Shortest Path in a Grid with Obstacles Elimination](1293.shortest-path-in-a-grid-with-obstacles-elimination.md)
+- [1091. Shortest Path in Binary Matrix](1091.shortest-path-in-binary-matrix.md)
+- [934. Shortest Bridge](934.shortest-bridge.md)
+- [127. Word Ladder](127.word-ladder.md)
+- [785. Is Graph Bipartite?](785.is-graph-bipartite.md)
+- [886. Possible Bipartition](886.possible-bipartition.md)
+- [3552. Grid Teleportation Traversal](3552.grid-teleportation-traversal.md)

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

@@ -1,16 +1,22 @@
-## [1162. As Far from Land as Possible](https://leetcode.com/problems/as-far-from-land-as-possible/)
+# [1162. As Far from Land as Possible](https://leetcode.com/problems/as-far-from-land-as-possible/)
 
-> TODO: Review the notes + implementations
+## Multi-source BFS
+We can enqueue all `1`s first, and then expand the level by level.
 
-### 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.
+> - 因为我们只要先把所有的陆地都入队，然后从各个陆地同时开始一层一层的向海洋扩散，那么最后扩散到的海洋就是最远的海洋！并且这个海洋肯定是被离他最近的陆地给扩散到的！
+> - 你可以想象成你从每个陆地上派了很多支船去踏上伟大航道，踏遍所有的海洋。每当船到了新的海洋，就会分裂成4条新的船，向新的未知海洋前进（访问过的海洋就不去了）。如果船到达了某个未访问过的海洋，那他们是第一个到这片海洋的。很明显，这么多船最后访问到的海洋，肯定是离陆地最远的海洋。
+> - 陆地不断长大，直到覆盖整个地图，计算扩大了多少轮，输出轮数即可
 
 ```kotlin
 fun maxDistance(grid: Array<IntArray>): Int {
     val n = grid.size
     var maxDistance = 0
 
-    val distances = Array(n) { IntArray(n) { Int.MAX_VALUE } }
+    // Approach 1: We need to maintain a distance matrix.
+    val distances = Array(n) { IntArray(n) { Int.MAX_VALUE } } 
+    // Approach 2: We need to avoid duplicate visit.
+    val visited = HashSet<Pair<Int, Int>>() 
+    
     // Find the nearest land
     val queue = ArrayDeque<Pair<Int, Int>>()
     var hasWater = false
@@ -20,6 +26,7 @@ fun maxDistance(grid: Array<IntArray>): Int {
             if (grid[i][j] == 1) {
                 queue.addLast(i to j)
                 distances[i][j] = 0
+                visited.add(i to j)
                 hasLand = true
             } else {
                 hasWater = true
@@ -28,28 +35,60 @@ fun maxDistance(grid: Array<IntArray>): Int {
     }
     if (!hasWater || !hasLand) return -1
 
-    while (queue.isNotEmpty()) {
-        val position = queue.removeFirst()
-        val x = position.first
-        val y = position.second
-        if (x < 0 || y < 0 || x >= n || y >= n) continue
+    // To be continued...
+}
+```
+
+- Approach 1: We use the same approach as [542. 01 Matrix](542.01-matrix.md), we can maintain a distance matrix, and the maximum distance is the answer during the update of distance during the traversal.
+
+```kotlin
+// Continue from the code above
+
+while (queue.isNotEmpty()) {
+    val position = queue.removeFirst()
+    val x = position.first
+    val y = position.second
 
-        directions.forEach { d ->
+    for (d in directions) {
+        val newX = x + d[0]
+        val newY = y + d[1]
+        if (newX !in 0 until n) continue
+        if (newY !in 0 until n) continue
+        if (distances[newX][newY] > distances[x][y] + 1) {
+            distances[newX][newY] = distances[x][y] + 1
+            queue.addLast(newX to newY)
+            maxDistance = max(maxDistance, distances[newX][newY])
+        }
+    }
+}
+return maxDistance
+```
+
+- Approach 2: We can use the same idea as [994. Rotting Oranges](994.rotting-orange.md) (multi-source BFS + level by level) to find the maximum distance, we enqueue all `1`s first, and then expand the level by level.
+
+```kotlin
+// Continue from the code above
+while (queue.isNotEmpty()) {
+    val size = queue.size
+    repeat (size) {
+        val (x, y) = queue.removeFirst()
+        for (d in directions) {
             val newX = x + d[0]
             val newY = y + d[1]
-            if (newX >= 0 && newY >= 0 && newX < n && newY < n) {
-                val distance = abs(newX - x) + abs(newY - y)
-                if (distances[newX][newY] > distances[x][y] + distance) {
-                    distances[newX][newY] = distances[x][y] + distance
-                    queue.addLast(newX to newY)
-
-                    if (distances[newX][newY] != Int.MAX_VALUE) {
-                        maxDistance = max(maxDistance, distances[newX][newY])
-                    }
-                }
+            if (newX !in 0 until n) continue
+            if (newY !in 0 until n) continue
+            if (visited.contains(newX to newY)) continue
+            if (grid[newX][newY] == 0) {
+                queue.addLast(newX to newY)
+                visited.add(newX to newY)
             }
         }
     }
-    return maxDistance
+    maxDistance++
 }
+/**
+We will enqueue the last level and increment the distance, so we need to subtract 1 from the result.
+As same as [994. Rotting Oranges](994.rotting-orange.md), we need to subtract 1 from the result.
+    */
+return maxDistance - 1
 ```