LC.1091. Shortest Path in Binary Matrix

class Solution(object):
    def shortestPathBinaryMatrix(self, grid):
        """
        之所以每次压栈以后能将grid[i][j]变成1，因为如果该位置已经有当前路径已经到达了，其他路径不需要再到达这个地方了，不然就是绕路没有意义
        带回溯的DFS之所以超时是因为DFS是一条条路径遍历的，每次都有多条路径选择，BFS多条路径并行搜索，将访问过的点进行标记减少了搜索空间
        """
        from collections import deque
        queue = deque()
        if grid[0][0] ==1 or grid[-1][-1] == 1:
            return -1
        queue.append((0,0,1))
        while(len(queue)):
            i,j,path = queue.popleft()
            if i == len(grid)-1 and j == len(grid[0])-1:
                return path
            for xx, yy in  ((i-1,j-1),(i-1,j),(i-1,j+1),(i,j-1),(i,j+1),(i+1,j-1),(i+1,j),(i+1,j+1)):
                if 0 <= xx < len(grid) and 0 <= yy < len(grid[0]) and grid[xx][yy] == 0:
                    grid[xx][yy] =1
                    queue.append((xx,yy,path+1))
        return -1

下面的方法会超时

class Solution(object):
    def shortestPathBinaryMatrix(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: int
        """
        self.res = float("inf")
        visited = [[0]*len(grid[0]) for i in range(len(grid))]

        if grid[0][0] == 0:
            self.DFS(0,0,0, grid,visited)
        return self.res if self.res != float("inf") else -1


    def DFS(self, x, y, path, grid, visited):
        if x == len(grid) -1 and y == len(grid[0]) -1:
            self.res = min(self.res, path+1)
        else:
            for xx, yy in self.neigh(x, y, grid):
                if visited[xx][yy] == 0:
                    visited[xx][yy] =1
                    self.DFS(xx, yy, path+1, grid, visited)
                    visited[xx][yy] =0

    def neigh(self, x, y, grid):
        for xx,yy in [(x-1,y-1), (x-1, y), (x-1,y+1),
                      (x,y-1), (x,y+1),
                      (x+1, y-1), (x+1, y), (x+1,y+1)]:
            if 0 <= xx < len(grid) and 0 <= yy < len(grid[0]) and grid[xx][yy]==0:
                yield  xx, yy