<p>You are given an <code>m x n</code> matrix <code>maze</code> (<strong>0-indexed</strong>) with empty cells (represented as <code>&#39;.&#39;</code>) and walls (represented as <code>&#39;+&#39;</code>). You are also given the <code>entrance</code> of the maze, where <code>entrance = [entrance<sub>row</sub>, entrance<sub>col</sub>]</code> denotes the row and column of the cell you are initially standing at.</p>

<p>In one step, you can move one cell <strong>up</strong>, <strong>down</strong>, <strong>left</strong>, or <strong>right</strong>. You cannot step into a cell with a wall, and you cannot step outside the maze. Your goal is to find the <strong>nearest exit</strong> from the <code>entrance</code>. An <strong>exit</strong> is defined as an <strong>empty cell</strong> that is at the <strong>border</strong> of the <code>maze</code>. The <code>entrance</code> <strong>does not count</strong> as an exit.</p>

<p>Return <em>the <strong>number of steps</strong> in the shortest path from the </em><code>entrance</code><em> to the nearest exit, or </em><code>-1</code><em> if no such path exists</em>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearest1-grid.jpg" style="width: 333px; height: 253px;" />
<pre>
<strong>Input:</strong> maze = [[&quot;+&quot;,&quot;+&quot;,&quot;.&quot;,&quot;+&quot;],[&quot;.&quot;,&quot;.&quot;,&quot;.&quot;,&quot;+&quot;],[&quot;+&quot;,&quot;+&quot;,&quot;+&quot;,&quot;.&quot;]], entrance = [1,2]
<strong>Output:</strong> 1
<strong>Explanation:</strong> There are 3 exits in this maze at [1,0], [0,2], and [2,3].
Initially, you are at the entrance cell [1,2].
- You can reach [1,0] by moving 2 steps left.
- You can reach [0,2] by moving 1 step up.
It is impossible to reach [2,3] from the entrance.
Thus, the nearest exit is [0,2], which is 1 step away.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearesr2-grid.jpg" style="width: 253px; height: 253px;" />
<pre>
<strong>Input:</strong> maze = [[&quot;+&quot;,&quot;+&quot;,&quot;+&quot;],[&quot;.&quot;,&quot;.&quot;,&quot;.&quot;],[&quot;+&quot;,&quot;+&quot;,&quot;+&quot;]], entrance = [1,0]
<strong>Output:</strong> 2
<strong>Explanation:</strong> There is 1 exit in this maze at [1,2].
[1,0] does not count as an exit since it is the entrance cell.
Initially, you are at the entrance cell [1,0].
- You can reach [1,2] by moving 2 steps right.
Thus, the nearest exit is [1,2], which is 2 steps away.
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2021/06/04/nearest3-grid.jpg" style="width: 173px; height: 93px;" />
<pre>
<strong>Input:</strong> maze = [[&quot;.&quot;,&quot;+&quot;]], entrance = [0,0]
<strong>Output:</strong> -1
<strong>Explanation:</strong> There are no exits in this maze.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>maze.length == m</code></li>
	<li><code>maze[i].length == n</code></li>
	<li><code>1 &lt;= m, n &lt;= 100</code></li>
	<li><code>maze[i][j]</code> is either <code>&#39;.&#39;</code> or <code>&#39;+&#39;</code>.</li>
	<li><code>entrance.length == 2</code></li>
	<li><code>0 &lt;= entrance<sub>row</sub> &lt; m</code></li>
	<li><code>0 &lt;= entrance<sub>col</sub> &lt; n</code></li>
	<li><code>entrance</code> will always be an empty cell.</li>
</ul>

"""
DFS or BFS while maintaining the steps from entrance taking the minimum once exploring all possibilities.
Do we want to do BFS or DFS?
BFS might be better since we can use the first result and find the answer quicker
what about cases where a path might snake around and we have multiple exits

O(nm) O(nm)

+ + + + . + + +
+ + + + . + + +
+ + + . . . + +
+ . . . + . . .
+ . + + + + + +
+ . . + + + + +
+ + . + + + + +
. . . + + + + +
+ + + + + + + +

worst case might be

+ + + + + . +
+ . . . . . +
+ . . . . . +
+ . . . . . +
+ + + + + + +
"""
class Point:
  def __init__(self, row, col, dist):
    self.row = row
    self.col = col
    self.dist = dist

class Solution:
    def getAdjacent(self, p: Point, maze: List[List[int]], visited: Set[Tuple[int,int]]) -> List[Point]:
        height = len(maze)
        width = len(maze[0])
        adj = []
        for coord in [[p.row-1, p.col], [p.row, p.col+1], [p.row+1, p.col], [p.row, p.col-1]]:
          r = coord[0]
          c = coord[1]
          if r < 0 or r >= height:
            continue
          if c < 0 or c >= width:
            continue
          if maze[r][c] != '.':
            continue
          if (r, c) in visited:
            continue
          pp = Point(r, c, p.dist+1)
          adj.append(pp)
        return adj
      
    def isExit(self, point: Point, maze: List[List[int]]):
        height = len(maze)
        width = len(maze[0])
        if point.dist > 0:
            return point.row == 0 or point.row == height-1 or point.col == 0 or point.col == width-1
        return False
  
    def nearestExit(self, maze: List[List[str]], entrance: List[int]) -> int:
        visited = set()
        q = collections.deque()
        p = Point(entrance[0], entrance[1], 0)
        q.append(p)
        while q:
          for _ in range(len(q)):
            p = q.popleft()
            if (p.row, p.col) in visited:
              continue
            if self.isExit(p, maze):
              return p.dist
            adj = self.getAdjacent(p, maze, visited)
            for a in adj:
              q.append(a)
            visited.add((p.row, p.col))
        return -1
          
752