Problems/graph (#24)

* Update array note

* Update graph note

* Update 59. Spiral Matrix II problem solution

* Add 797. All Paths From Source to Target solution

* Add 797. All Paths From Source to Target recursive solution

* Add 797. All Paths From Source to Target bfs solution

* Add 733. Flood Fill solution

* Add 733. Flood Fill dfs solution

* Update 387. First Unique Character in a String solution

* Update graph problems and 242. Valid Anagram solution

* Add 200. Number of Islands solution

* Add 130. Surrounded Regions solution

* Add 695. Max Area of Island solution

* Add 200. Number of Islands BFS solution

* Add 542. 01 Matrix solution

* Add 994. Rotting Oranges solution

* Add 310. Minimum Height Trees attempt

* Add 417. Pacific Atlantic Water Flow solution

* Add 785. Is Graph Bipartite? solution

* Add 1254. Number of Closed Islands solution

* Add 841. Keys and Rooms solution

* Add linked list sentinel node template

* Update linked list problems note

* Add 127. Word Ladder solution

* Update 141. Linked List Cycle solution

* Add 207. Course Schedule solution

* Add 210. Course Schedule II solution

* Add 743. Network Delay Time solutions

* Add 399. Evaluate Division solution

* Update 743. Network Delay Time dijkstra] algorithm solution

* Add 1091. Shortest Path in Binary Matrix solution

* Add 787. Cheapest Flights Within K Stops attempt

* Update 92. Reverse Linked List II solution

* Update 234. Palindrome Linked List solution

* Add update graph problem solving tips

Author: enginebai

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

@@ -0,0 +1,49 @@
+## [1091. Shortest Path in Binary Matrix](https://leetcode.com/problems/shortest-path-in-binary-matrix/)
+
+```kotlin
+fun shortestPathBinaryMatrix(grid: Array<IntArray>): Int {
+    val infinite = Int.MAX_VALUE / 2
+    val n = grid.size
+    if (grid[0][0] == 1 || grid[n -1][n - 1] == 1) return -1
+    
+    val distances = Array(n) { _ -> IntArray(n) { _ -> infinite }}
+    val queue = ArrayDeque<Pair<Int, Int>>()
+    val visited = hashSetOf<Pair<Int, Int>>()
+    queue.add(0 to 0)
+    visited.add(0 to 0)
+    distances[0][0] = 1
+    while (!queue.isEmpty()) {
+        val node = queue.removeFirst()
+        val x = node.first
+        val y = node.second
+        
+        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)
+        )
+        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
+                }
+
+                if (!visited.contains(newX to newY)) {
+                    queue.addLast(newX to newY)
+                    visited.add(newX to newY)
+                }
+            }
+        }
+    }
+    val result = distances[n - 1][n - 1]
+    return if (result == infinite) -1 else result
+}
+```

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

@@ -0,0 +1,51 @@
+## [1254. Number of Closed Islands](https://leetcode.com/problems/number-of-closed-islands/)
+
+* We traversal 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 nonClosedLands = hashSetOf<Pair<Int, Int>>()
+    private val directions = arrayOf(
+        -1 to 0, 1 to 0, 0 to -1, 0 to 1)
+    
+    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
+    }
+    
+    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)
+            }
+        }
+    }
+}
+```

leetcode/127.word-ladder.md

@@ -0,0 +1,63 @@
+## [127. Word Ladder](https://leetcode.com/problems/word-ladder/)
+
+* Build the graph: the pair words that differ by one character will be the edge.
+
+```js
+hot:[dot,lot,]
+dot:[hot,dog,lot,]
+dog:[dot,log,cog,]
+lot:[hot,dot,log,]
+log:[dog,lot,cog,]
+cog:[dog,log,]
+```
+
+* Run BFS on the graph that calculates the shortest path.
+
+```kotlin
+fun ladderLength(beginWord: String, endWord: String, wordList: List<String>): Int {
+    if (beginWord == endWord) return 0
+    val queue = ArrayDeque<String>()
+    val visited = hashSetOf<String>()
+    val graph = mutableMapOf<String, MutableSet<String>>()
+    graph[beginWord] = mutableSetOf<String>()
+    for (word in wordList) {
+        if (diff(beginWord, word) == 1) graph[beginWord]?.add(word)
+    }
+    for (word1 in wordList) {
+        graph[word1] = mutableSetOf()
+        for (word2 in wordList) {
+            if (diff(word1, word2) == 1) graph[word1]?.add(word2)
+        }
+    }
+    
+    queue.addLast(beginWord)
+    visited.add(beginWord)
+    
+    var distance = 1
+    while (!queue.isEmpty()) {
+        val size = queue.size
+        for (i in 0 until size) {
+            val currentWord = queue.removeFirst()    
+            graph[currentWord]?.forEach { word ->
+                if (!visited.contains(word)) {
+                    if (word == endWord) {
+                        return distance + 1
+                    }
+                    visited.add(word)
+                    queue.addLast(word)
+                }
+            }
+        }
+        distance++
+    }
+    return 0
+}
+
+private fun diff(w1: String, w2: String): Int {
+    var diff = 0
+    for (i in 0 until w1.length) {
+        if (w1[i] != w2[i]) diff++
+    }
+    return diff
+}
+```

leetcode/130.surrounded-regions.md

@@ -0,0 +1,48 @@
+## [130. Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)
+
+
+```kotlin
+class Solution {
+    
+    private val regions = hashSetOf<Pair<Int, Int>>()
+    private val visited = hashSetOf<Pair<Int, Int>>()
+    
+    fun solve(board: Array<CharArray>): Unit {
+        for (m in 0 until board.size) {
+            for (n in 0 until board[m].size) {
+                if (board[m][n] == 'O' && !visited.contains(m to n)) {
+                    val currentRegions = hashSetOf<Pair<Int, Int>>()
+                    if (dfs(board, m, n, currentRegions)) {
+                        regions.addAll(currentRegions)
+                    }
+                }
+            }
+        }
+        
+        regions.forEach {
+            board[it.first][it.second] = 'X'
+        }
+    }
+    
+    private fun dfs(board: Array<CharArray>, x: Int, y: Int, regions: HashSet<Pair<Int, Int>>): Boolean {
+        if (x < 0 || y < 0 || x > board.size - 1 || y > board[0].size - 1) return false
+        if (board[x][y] == 'X' || visited.contains(x to y)) return true
+        
+        visited.add(x to y)
+        regions.add(x to y)
+        
+        val up = dfs(board, x - 1, y, regions)
+        val down = dfs(board, x + 1, y, regions)
+        val left = dfs(board, x, y - 1, regions)
+        val right = dfs(board, x, y + 1, regions)
+        return up && down && left && right
+    }
+}
+```
+
+### Failed Cases
+```js
+O X X
+O O X
+O X X
+```

leetcode/141.linked-list-cycle.md

@@ -24,14 +24,34 @@ We can use two pointers approach to solve this with `O(1)` space:
 fun hasCycle(head: ListNode?): Boolean {
     var slow: ListNode? = head
     var fast: ListNode? = head
-    while (fast != null && fast?.next != null) {
+    while (fast != null && fast.next != null) {
         show = show?.next
         fast = fast?.next?.next
+        if (fast == slow) return true
+    }
+    return false
+}
+```
 
-        if (show == fast) {
-            return true
-        }
+For two pointers approach, there are some equivalent implementations:
+
+> **Important**!! But we will choose above impelementation since it will affect the idea and result of [142. Linked List Cycle II](https://leetcode.com/problems/linked-list-cycle-ii/).
+
+```kotlin
+/// Slow 1, fast 2
+//	    **Slow 2, fast 4
+// Slow 2, fast 4
+//	    **Slow 3, fast 3
+// Slow 3, fast 3
+//true
+fun hasCycle2(head: ListNode?): Boolean {
+    var slow: ListNode? = head
+    var fast: ListNode? = head?.next
+    while (slow != null) {
+        if (slow == fast) return true
+        slow = slow.next
+        fast = fast?.next?.next
     }
     return false
 }
-```
+```

leetcode/142.linked-list-cycle-ii.md

@@ -18,6 +18,8 @@ fun detectCycle(head: ListNode?): ListNode? {
 We can use two pointers approach to solve this with `O(1)` space. (like [the solution](../leetcode/141.linked-list-cycle.md) with some extra steps)
 
 > Explanation: https://leetcode.cn/problems/linked-list-cycle-ii/solution/142-huan-xing-lian-biao-ii-jian-hua-gong-shi-jia-2/
+>
+> There are some equivalent two pointers implementation, but we have make sure that `slow` and `fast` pointers **start from the same node**!!.
 
 ```kotlin
 fun detectCycle(head: ListNode?): ListNode? {

leetcode/200.number-of-islands.md

@@ -0,0 +1,69 @@
+## [200. Number of Islands](https://leetcode.com/problems/number-of-islands/)
+
+### DFS
+```kotlin
+class Solution {
+    
+    private val visited = hashSetOf<Pair<Int, Int>>()       
+    private var numberOfIslands = 0
+    
+    fun numIslands(grid: Array<CharArray>): Int {
+        
+        for (m in 0 until grid.size) {
+            for (n in 0 until gridcharArrayOf(m).size) {
+                if (!visited.contains(m to n) && gridcharArrayOf(m)charArrayOf(n) == '1') {
+                    dfs(grid, m, n)
+                    numberOfIslands++
+                }
+            }
+        }
+        return numberOfIslands
+    }
+    
+    private fun dfs(grid: Array<CharArray>, x: Int, y: Int) {
+        if (x < 0 || y < 0 || x >= grid.size || y >= gridcharArrayOf(0).size || gridcharArrayOf(x)charArrayOf(y) == '0' || visited.contains(x to y)) return
+        
+        visited.add(x to y)
+        dfs(grid, x - 1, y)
+        dfs(grid, x + 1, y)
+        dfs(grid, x, y - 1)
+        dfs(grid, x, y + 1)
+    }
+}
+```
+
+### BFS
+```kotlin
+class Solution {
+    private val visited = hashSetOf<Pair<Int, Int>>()
+    fun numIslands(grid: Array<CharArray>): Int {
+        var numOfIslands = 0
+        
+        for (m in 0 until grid.size) {
+            for (n in 0 until grid[m].size) {
+                if (grid[m][n] == '1' && !visited.contains(m to n)) {
+                    val queue = ArrayDeque<Pair<Int, Int>>()
+                    queue.addLast(m to n)
+                    while (!queue.isEmpty()) {
+                        val node = queue.removeFirst()
+                        val x = node.first
+                        val y = node.second
+                        
+                        if (!validPosition(grid, x, y)) continue
+                        visited.add(x to y)
+                        queue.addLast(x - 1 to y)
+                        queue.addLast(x + 1 to y)
+                        queue.addLast(x to y - 1)
+                        queue.addLast(x to y + 1)
+                    }
+                    numOfIslands++
+                }
+            }
+        }
+        return numOfIslands
+    }
+    
+    private fun validPosition(grid: Array<CharArray>, x: Int, y: Int) =
+        x in 0..grid.size - 1 && y in 0..grid[x].size - 1 && grid[x][y] == '1' && !visited.contains(x to y)
+}
+```

leetcode/203.remove-linked-list-elements.md

@@ -11,7 +11,7 @@
 When deleting a node, we can implement in the following way:
 
 ```kotlin
-var previous: ListNode? = sentinel
+var previous: ListNode? = null
 var current: ListNode? = head
 while (current != null) {
     if (current == nodeToDelete) {
@@ -31,6 +31,7 @@ We introduce *sentinel node* to help us when deleting the head node so that we c
 fun removeElements(head: ListNode?, `val`: Int): ListNode? {
     val sentinel = ListNode(-1)
     sentinel.next = head
+    // Here is different part.
     var previous: ListNode? = sentinel
     var current: ListNode? = head
     while (current != null) {

leetcode/206.reverse-linked-list.md

@@ -1,11 +1,6 @@
 ## [206. Reverse Linked List](https://leetcode.com/problems/reverse-linked-list/)
 
 ```kotlin
-data class ListNode(
-    val value: Int,
-    var next: ListNode? = null
-)
-
 fun reverseList(head: ListNode?): ListNode? {
     var previous: ListNode? = null
     var current: ListNode? = head
@@ -21,3 +16,4 @@ fun reverseList(head: ListNode?): ListNode? {
     return previous
 }
 ```
+