added Escape Large Maze (hard)

Author: minhyeong-joe

Hard/EscapeLargeMaze/README.md

@@ -0,0 +1,35 @@
+
+# Escape a Large Maze
+[Leetcode Link](https://leetcode.com/problems/escape-a-large-maze/)
+
+## Problem:
+
+In a 1 million by 1 million grid, the coordinates of each grid square are `(x, y)` with `0 <= x, y < 10^6`.
+
+We start at the `source` square and want to reach the `target` square. Each move, we can walk to a 4-directionally adjacent square in the grid that isn't in the given list of `blocked` squares.
+
+Return `true` if and only if it is possible to reach the target square through a sequence of moves.
+
+## Example:
+
+```
+Input: blocked = [[0,1],[1,0]], source = [0,0], target = [0,2]
+Output: false
+Explanation: 
+The target square is inaccessible starting from the source square, because we can't walk outside the grid.
+```
+```
+Input: blocked = [], source = [0,0], target = [999999,999999]
+Output: true
+Explanation: 
+Because there are no blocked cells, it's possible to reach the target square.
+```
+
+## Note:
+
+- `0 <= blocked.length <= 200`
+- `blocked[i].length == 2`
+- `0 <= blocked[i][j] < 10^6`
+- `source.length == target.length == 2`
+- `0 <= source[i][j], target[i][j] < 10^6`
+- `source != target`

Hard/EscapeLargeMaze/solution.py

@@ -0,0 +1,36 @@
+from typing import List
+
+# test size is reduced to 10 x 10 grid for visual debugging
+class Solution:
+ def isEscapePossible(self, blocked: List[List[int]], source: List[int], target: List[int]) -> bool:
+ N = 10
+ # queue for BFS
+ queue = list()
+ visited = set()
+ queue.append(source)
+ while queue:
+ print("queue:", queue)
+ print("visited:", visited)
+ currentCoord = queue.pop(0)
+ if currentCoord == target:
+ return True
+ visited.add(tuple(currentCoord))
+ # get four neighboring coordinates and add to queue if not visited and is valid (not blocked and not outside boundary)
+ if currentCoord[0]-1 >= 0 and (currentCoord[0]-1,currentCoord[1]) not in visited and [currentCoord[0]-1,currentCoord[1]] not in blocked:
+ queue.append([currentCoord[0]-1, currentCoord[1]])
+ if currentCoord[0]+1 < N and (currentCoord[0]+1, currentCoord[1]) not in visited and [currentCoord[0]+1, currentCoord[1]] not in blocked:
+ queue.append([currentCoord[0]+1, currentCoord[1]])
+ if currentCoord[1]-1 >= 0 and (currentCoord[0], currentCoord[1]-1) not in visited and [currentCoord[0], currentCoord[1]-1] not in blocked:
+ queue.append([currentCoord[0], currentCoord[1]-1])
+ if currentCoord[1]+1 < N and (currentCoord[0], currentCoord[1]+1) not in visited and [currentCoord[0], currentCoord[1]+1] not in blocked:
+ queue.append([currentCoord[0], currentCoord[1]+1])
+ 
+ return False
+
+
+# test driver
+sol = Solution()
+blocked = [[1,2], [0,2], [2,2]]
+source = [0,0]
+target = [3,3]
+print("Output:", sol.isEscapePossible(blocked, source, target))

README.md

@@ -85,6 +85,7 @@ Languages used: Java and Python
  - [First Missing Positive](Hard/FirstMissingPositive)
  - [Insert Interval](Hard/InsertInterval)
  - [Find Median From Data Stream](Hard/FindMedianFromDataStream)
+ - [Escape a Large Maze](Hard/EscapeLargeMaze)
 
 ---