Update graph, shortest path and backtracking problem solutions

Author: enginebai

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

@@ -1,49 +1,44 @@
 ## [1091. Shortest Path in Binary Matrix](https://leetcode.com/problems/shortest-path-in-binary-matrix/)
 
 ```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)
+        )
+
 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)
-        )
+        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
-                }
-
-                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
+    return -1
 }
 ```

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

@@ -6,7 +6,6 @@
 ```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)
 

leetcode/127.word-ladder.md

@@ -1,6 +1,6 @@
 ## [127. Word Ladder](https://leetcode.com/problems/word-ladder/)
 
-* Build the graph: the pair words that differ by one character will be the edge.
+* Build the graph: the pair words that differ by one character will be the adjanct edge.
 
 ```js
 hot:[dot,lot,]
@@ -15,45 +15,40 @@ cog:[dog,log,]
 
 ```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)
+    val visited = BooleanArray(wordList.size)
+    var currentWord = beginWord
+    val queue = ArrayDeque<Int>()
+    for (i in 0 until wordList.size) {
+        if (wordList[i] == beginWord) visited[i] = true
+        else if (getDiff(currentWord, wordList[i]) == 1) {
+            queue.addLast(i)
         }
     }
 
-    queue.addLast(beginWord)
-    visited.add(beginWord)
-    
-    var distance = 1
-    while (!queue.isEmpty()) {
+    // 1 for beginWord
+    var counts = 1
+    while (queue.isNotEmpty()) {
         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)
+            val index = queue.removeFirst()
+            if (visited[index]) continue
+            if (wordList[index] == endWord) return counts + 1 // +1 for endWord
+            visited[index] = true
+            currentWord = wordList[index]
+            
+            for (j in 0 until wordList.size) {
+                if (!visited[j] && getDiff(currentWord, wordList[j]) == 1) {
+                    queue.addLast(j)
                 }
             }
         }
-        distance++
+        counts++
     }
     return 0
 }
 
-private fun diff(w1: String, w2: String): Int {
+private fun getDiff(w1: String, w2: String): Int {
+    if (w1 == w2) return 0
     var diff = 0
     for (i in 0 until w1.length) {
         if (w1[i] != w2[i]) diff++

leetcode/130.surrounded-regions.md

@@ -1,6 +1,6 @@
 ## [130. Surrounded Regions](https://leetcode.com/problems/surrounded-regions/)
 
-
+### Traversal
 ```kotlin
 class Solution {
 
@@ -40,6 +40,59 @@ class Solution {
 }
 ```
 
+### Bounary DFS
+We start from four boundaries, and find the regions we don't capture, and iterate the whole board again to capture the remaining regions that really need to capture.
+
+```kotlin
+private val directions = arrayOf(
+    intArrayOf(-1, 0),
+    intArrayOf(1, 0),
+    intArrayOf(0, -1),
+    intArrayOf(0, 1)
+)
+private val notCapture = 'A'
+
+fun solve(board: Array<CharArray>): Unit {
+    val m = board.size
+    val n = board[0].size
+    // First row
+    for (c in 0 until n) {
+        dfs(board, 0, c)
+    }
+    // First col
+    for (r in 0 until m) {
+        dfs(board, r, 0)
+    }
+    
+    // Last row
+    for (c in 0 until n) {
+        dfs(board, m - 1, c)
+    }
+    
+    // Last col
+    for (r in 0 until m) {
+        dfs(board, r, n - 1)
+    }
+    
+    for (i in 0 until m) {
+        for (j in 0 until n) {
+            // Capture
+            if (board[i][j] == 'O') board[i][j] = 'X'
+            // Recover
+            else if (board[i][j] == notCapture) board[i][j] = 'O' 
+        }
+    }
+}
+
+private fun dfs(board: Array<CharArray>, x: Int, y: Int) {
+    if (x < 0 || x >= board.size || y < 0 || y >= board[0].size || board[x][y] != 'O') return
+    board[x][y] = notCapture
+    directions.forEach { d -> 
+        dfs(board, x + d[0], y + d[1])
+    }
+}
+```
+
 ### Failed Cases
 ```js
 O X X

leetcode/139.word-break.md

@@ -29,27 +29,81 @@ i  j  c a r s
 
 ```kotlin
 fun wordBreak(s: String, wordDict: List<String>): Boolean {
-    val wordDictSet = HashSet(wordDict)
+    val wordDictSet = HashSet<String>(wordDict)
     val dp = BooleanArray(s.length + 1)
-
-    // Base case: it's always true for empty string case
     dp[0] = true
-
-    // Iterate every states
-    for (i in 1..s.length) {
-        for (j in 0 until i) {
-            val substring = s.substring(j, i)
-            // The state of s[0:j] and the state of s[j:i]
-            if (dp[j] && wordDictSet.contains(substring)) {
-                dp[i] = true
+    for (end in 1..s.length) {
+        for (start in 0..end) {
+            val suffix = s.substring(start, end)
+            println("$start, $end, $suffix")
+            if (dp[start] && wordDictSet.contains(suffix)) {
+                dp[end] = true
                 break
             }
         }
+        for (i in 0 until dp.size) {
+            print("${dp[i]},")
+        }
+        println()
     }
     return dp[s.length]
 }
 ```
 
+```js
+println(wordBreak("cars", listOf("car", "rs", "ca")))
+0, 1, c
+1, 1, 
+true,false,false,false,false,
+0, 2, ca
+true,false,true,false,false,
+0, 3, car
+true,false,true,true,false,
+0, 4, cars
+1, 4, ars
+2, 4, rs
+true,false,true,true,true,
+true
+
+println(wordBreak("cars", listOf("c", "s", "ar")))
+0, 1, c
+true,true,false,false,false,
+0, 2, ca
+1, 2, a
+2, 2, 
+true,true,false,false,false,
+0, 3, car
+1, 3, ar
+true,true,false,true,false,
+0, 4, cars
+1, 4, ars
+2, 4, rs
+3, 4, s
+true,true,false,true,true,
+true
+
+println(wordBreak("cars", listOf("s", "ar")))
+0, 1, c
+1, 1, 
+true,false,false,false,false,
+0, 2, ca
+1, 2, a
+2, 2, 
+true,false,false,false,false,
+0, 3, car
+1, 3, ar
+2, 3, r
+3, 3, 
+true,false,false,false,false,
+0, 4, cars
+1, 4, ars
+2, 4, rs
+3, 4, s
+4, 4, 
+true,false,false,false,false,
+false
+```
+
 * **Time Complexity**: `O(n^2)` where `n` is the length of string.
 * **Space Complexity**: `O(n)` for dp table.
 

leetcode/152.maximum-product-subarray.md

@@ -5,27 +5,20 @@ Similar idea from [53. Maximum Subarray](../leetcode/53.maximum-subarray.md), bu
 
 ```kotlin
 fun maxProduct(nums: IntArray): Int {
-    if (nums.size == 1) return nums[0]
-    // We store local maximum [0] and minimum [1].
-    val dp = Array(nums.size) { _ -> IntArray(2) }
+    val localMax = IntArray(nums.size)
+    val localMin = IntArray(nums.size)
     var globalMax = nums[0]
-    dp[0] = intArrayOf(nums[0], nums[0])
+    localMax[0] = nums[0]
+    localMin[0] = nums[0]
     for (i in 1 until nums.size) {
         val current = nums[i]
-        val maxProduct = dp[i - 1][0] * current
-        val minProduct = dp[i - 1][1] * current
+        val productOfPreviousMax = current * localMax[i - 1]
+        val productOfPreviousMin = current * localMin[i - 1]
 
-        dp[i] = intArrayOf(
-            max(
-                current, 
-                max(maxProduct, minProduct)
-            ), 
-            min(
-                current, 
-                min(maxProduct, minProduct)
-            )
-        )
-        globalMax = max(globalMax, dp[i][0])
+        localMax[i] = max(max(current, productOfPreviousMax), productOfPreviousMin)
+        localMin[i] = min(min(current, productOfPreviousMax), productOfPreviousMin)
+        
+        globalMax = max(localMax[i], globalMax)
     }
     return globalMax
 }