from collections import deque

    def zero_one_bfs(graph, source):

        n = len(graph)
        dist = [float('inf')] * n
        dist[source] = 0

        dq = deque()
        dq.append(source)

        while dq:
            node = dq.popleft()
            for neighbor, weight in graph[node]:
                if dist[node] + weight < dist[neighbor]:
                    dist[neighbor] = dist[node] + weight
                    if weight == 0:
                        dq.appendleft(neighbor)  # 0-weight edges prioritized
                    else:
                        dq.append(neighbor)      # 1-weight edges go to back

        return dist

  oh! pseudocode hasn't been written yet, try another card! :)

    def minimumObstacles(self, grid: List[List[int]]) -> int:
        # Grid dimensions
        m, n = len(grid), len(grid[0])

        # Directions: up, down, left, right
        directions = [(1,0), (-1,0), (0,1), (0,-1)]

        # distance matrix: min obstacles removed to reach each cell
        dist = [[float('inf')] * n for _ in range(m)]
        dist[0][0] = grid[0][0]  # starting cost (remove if starting on 1)

        # deque for 0-1 BFS
        dq = deque()
        dq.append((0,0))

        while dq:

            r, c = dq.popleft()

            # Explore neighbors
            for dr, dc in directions:
                nr, nc = r + dr, c + dc

                # Valid boundaries
                if 0 <= nr < m and 0 <= nc < n:

                    # New distance = current + cost to enter neighbor
                    new_dist = dist[r][c] + grid[nr][nc]

                    # Relaxation
                    if new_dist < dist[nr][nc]:
                        dist[nr][nc] = new_dist

                        # 0-cost move → appendleft
                        if grid[nr][nc] == 0:
                            dq.appendleft((nr, nc))
                        # 1-cost move → append to back
                        else:
                            dq.append((nr, nc))

        # Result: min obstacles to remove to reach bottom-right
        return dist[m-1][n-1]

  oh! pseudocode hasn't been written yet, try another card! :)

    def minCost(self, grid):
        m, n = len(grid), len(grid[0])
        
        # directions: right, left, down, up
        dirs = [(0,1), (0,-1), (1,0), (-1,0)]
        
        # visited[i][j] = minimum cost to reach (i,j)
        visited = [[float('inf')] * n for _ in range(m)]
        visited[0][0] = 0
        
        dq = deque()
        dq.append((0,0,0))  # i, j, cost
        
        while dq:
            i, j, cost = dq.popleft()
            
            for d, (dx, dy) in enumerate(dirs, start=1):
                ni, nj = i + dx, j + dy
                
                if 0 <= ni < m and 0 <= nj < n:
                    # If we follow the arrow, cost = 0; otherwise cost = 1
                    new_cost = cost if d == grid[i][j] else cost + 1
                    
                    if new_cost < visited[ni][nj]:
                        visited[ni][nj] = new_cost
                        if d == grid[i][j]:
                            dq.appendleft((ni, nj, new_cost))  # 0-cost → front
                        else:
                            dq.append((ni, nj, new_cost))      # 1-cost → back
        
        return visited[m-1][n-1]

  oh! pseudocode hasn't been written yet, try another card! :)

    def minPushBox(self, grid: List[List[str]]) -> int:
        
        # 01 BFS over the (box position, player position) state graph

        # Unlike a plain grid BFS, the real state here isn't just a
        # single cell, it's the pair (box position, player position),
        # since where the box can be pushed next depends on whether the
        # player can maneuver to the correct side of it. Two kinds of
        # edges exist between states: the player repositioning without
        # touching the box (free, cost 0), and the player pushing the
        # box into an adjacent cell (a real move, cost 1). 01 BFS uses
        # a deque instead of a plain queue so 0-cost edges are explored
        # before 1-cost edges, keeping the frontier processed in true
        # non-decreasing cost order without needing a full priority queue.

        m, n = len(grid), len(grid[0])
        dirs = [(-1, 0), (1, 0), (0, -1), (0, 1)]

        # Locate Key Cells:
        # scan once to find the starting player, box, and target positions
        for r in range(m):
            for c in range(n):
                if grid[r][c] == 'S':
                    player = (r, c)
                elif grid[r][c] == 'B':
                    box = (r, c)
                elif grid[r][c] == 'T':
                    target = (r, c)

        def isFree(r, c):
            # In Bounds And Walkable:
            # a cell is usable if it's on the grid and not a wall
            return 0 <= r < m and 0 <= c < n and grid[r][c] != '#'

        # State Encoding:
        # a state bundles box position and player position together,
        # since the same box location can have different reachable
        # pushes depending on where the player currently stands
        start = (box[0], box[1], player[0], player[1])
        dist = {start: 0}
        dq = deque([start])
        done = set()

        while dq:

            # Pop a state from the front of the deque
            state = dq.popleft()

            # Early Pruning:
            # skip if this state was already finalized with an equal or
            # lower cost through an earlier pop, since 01 BFS guarantees
            # the first finalization of a state is optimal
            if state in done:
                continue
            done.add(state)

            br, bc, pr, pc = state
            cost = dist[state]

            # Check:
            # if the box has reached target, we are guaranteed to have
            # the minimum number of pushes
            if (br, bc) == target:
                return cost

            # Player Repositioning (cost 0):
            # the player can step to any free adjacent cell that isn't
            # occupied by the box, without counting as a push
            for dr, dc in dirs:
                npr, npc = pr + dr, pc + dc
                if isFree(npr, npc) and (npr, npc) != (br, bc):
                    nstate = (br, bc, npr, npc)
                    if nstate not in dist or dist[nstate] > cost:
                        dist[nstate] = cost
                        dq.appendleft(nstate)

            # Box Pushing (cost 1):
            # a push in direction (dr, dc) requires the player standing
            # on the opposite side of the box, and the destination cell
            # for the box must itself be free
            for dr, dc in dirs:
                ppos = (br - dr, bc - dc)
                nbr, nbc = br + dr, bc + dc
                if isFree(nbr, nbc) and isFree(*ppos) and ppos == (pr, pc):
                    nstate = (nbr, nbc, br, bc)
                    ncost = cost + 1
                    if nstate not in dist or dist[nstate] > ncost:
                        dist[nstate] = ncost
                        dq.append(nstate)

        # overall: tc O(m^2 * n^2), since each of the O(m*n) box
        #   positions can pair with each of the O(m*n) player positions,
        #   and every state is expanded a constant number of times
        # overall: sc O(m^2 * n^2), for the dist map and done set storing
        #   every explored (box, player) state pair
        return -1