Update Solution.kt

Author: ThanhNIT

src/main/kotlin/g1001_1100/s1036_escape_a_large_maze/Solution.kt

@@ -4,49 +4,66 @@ package g1001_1100.s1036_escape_a_large_maze
 // #2023_05_25_Time_387_ms_(100.00%)_Space_94.1_MB_(100.00%)
 
 class Solution {
+    private val MAX_COORD = 999999
+    private val LARGE_NUMBER = 1000000
+
     fun isEscapePossible(blocked: Array<IntArray>, source: IntArray, target: IntArray): Boolean {
         if (blocked.isEmpty()) {
             return true
         }
 
-        val blocks = mutableSetOf<Int>()
+        val blocks = HashSet<Int>()
         for (b in blocked) {
-            if (target[0] * 1_000_000 + target[1] != b[0] * 1_000_000 + b[1]) {
-                blocks.add(b[0] * 1_000_000 + b[1])
-            }
+            blocks.add(b[0] * LARGE_NUMBER + b[1])
         }
 
-        return dfs(blocks, source, source[0], source[1], mutableSetOf(), target) &&
-            dfs(blocks, target, target[0], target[1], mutableSetOf(), source)
+        return dfs(blocks, source, target, HashSet()) &&
+            dfs(blocks, target, source, HashSet())
     }
 
     private fun dfs(
         blocks: Set<Int>,
         start: IntArray,
-        i: Int,
-        j: Int,
-        visited: MutableSet<Int>,
         target: IntArray,
+        visited: HashSet<Int>,
     ): Boolean {
-        if (i < 0 || j < 0 || i > 999_999 || j > 999_999) {
+        val i = start[0]
+        val j = start[1]
+        val hash = i * LARGE_NUMBER + j
+
+        if (i < 0 || j < 0 || i > MAX_COORD || j > MAX_COORD || blocks.contains(hash)) {
             return false
         }
-        val pos = i * 1_000_000 + j
-        if (blocks.contains(pos) || visited.contains(pos)) {
+
+        if (visited.contains(hash)) {
             return false
         }
+
         if (i == target[0] && j == target[1]) {
             return true
         }
 
-        visited.add(pos)
+        visited.add(hash)
+
         if (visited.size > blocks.size * (blocks.size + 1)) {
             return true
         }
 
-        return dfs(blocks, start, i + 1, j, visited, target) ||
-            dfs(blocks, start, i - 1, j, visited, target) ||
-            dfs(blocks, start, i, j + 1, visited, target) ||
-            dfs(blocks, start, i, j - 1, visited, target)
+        val directions = listOf(
+            intArrayOf(1, 0),
+            intArrayOf(-1, 0),
+            intArrayOf(0, 1),
+            intArrayOf(0, -1),
+        )
+
+        for (dir in directions) {
+            val nextI = i + dir[0]
+            val nextJ = j + dir[1]
+            if (dfs(blocks, intArrayOf(nextI, nextJ), target, visited)) {
+                return true
+            }
+        }
+
+        return false
     }
 }