Why my code is giving TLE while a similar implementation passes (BFS)?

I am solving this question. I am implementing BFS and my implementation is as follows:

class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:

        if grid[0][0] == 1:
            return -1
        M=len(grid)-1
        seen = set()
        q = deque([])
        res = float('inf')
        q.append((0,0,1))

        while q:
            r,c, curr = q.popleft()
            if r==M and c==M:
                return curr
            directions = [[1,0], [0,1], [1,1], [-1,0], [0,-1], [-1,-1], [1, -1], [-1, 1]]
            seen.add((r,c))
            for ro, co in directions:
                nr, nc = r+ro, c+co
                if (nr,nc) in seen or nr < 0 or nc < 0 or nr > M or nc > M or grid[nr][nc] == 1:
                    continue
                q.append((nr,nc,curr+1))
        return -1

but this gives TLE for large input. However, a similar implementation passes:

class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:
        N = len(grid)
        q = deque([(0, 0, 1)]) # r, c, length
        visit = set((0, 0))
        direct = [[0, 1], [1, 0], [0, -1], [-1, 0],
                  [1, 1], [-1, -1], [1, -1], [-1, 1]]
        while q:
            r, c, length = q.popleft()
            if (min(r, c) < 0 or max(r, c) >= N or
                grid[r][c]):
                continue
            if r == N - 1 and c == N - 1:
                return length
            for dr, dc in direct:
                if (r + dr, c + dc) not in visit:
                    q.append((r + dr, c + dc, length + 1))
                    visit.add((r + dr, c + dc))
        return -1

What is slowing my code down?

I am unable to understand why my code is slower.

You solution would pass with just two small changes.

class Solution:
    def shortestPathBinaryMatrix(self, grid: List[List[int]]) -> int:

        if grid[0][0] == 1:
            return -1
        M=len(grid)-1
        seen = set([(0,0)])  # <-- initialize with (0, 0)
        q = deque([])
        res = float('inf')
        q.append((0,0,1))

        while q:
            r,c, curr = q.popleft()
            if r==M and c==M:
                return curr
            directions = [[1,0], [0,1], [1,1], [-1,0], [0,-1], [-1,-1], [1, -1], [-1, 1]]
            
            for ro, co in directions:
                nr, nc = r+ro, c+co
                if (nr,nc) in seen or nr < 0 or nc < 0 or nr > M or nc > M or grid[nr][nc] == 1:
                    continue
                q.append((nr,nc,curr+1))
                seen.add((nr,nc))  # <-- mark nodes that surely will be visited
        return -1

Note that the main change in the logic is that the line to add visited cells to seen is moved to the same level where new cells are added to the queue.

The drawback of the original code is that it cannot avoid duplication when duplicated cells are added to the queue on the same BFS level, because seen is not updated along with the queue.

Moving the update of seen to the same level as the update of queue guarantees that only unique cells are added to the queue for the next level of BFS.