幅優先探索 (BFS) で全部の部屋からいちばん近い出口までの歩数を求める

from collections import deque

STEPS = ((1, 0), (-1, 0),
         (0, 1), (0, -1))


def exit_distance(grid):
    h = len(grid)
    w = len(grid[0])
    dist = [[-1] * w
            for _ in range(h)]
    q = deque()
    for r in range(h):
        for c in range(w):
            if grid[r][c] == 0:
                dist[r][c] = 0
                q.append((r, c))
    while q:
        r, c = q.popleft()
        d = dist[r][c] + 1
        for dy, dx in STEPS:
            y = r + dy
            x = c + dx
            if y < 0 or y >= h:
                continue
            if x < 0 or x >= w:
                continue
            if dist[y][x] == -1:
                dist[y][x] = d
                q.append((y, x))
    return dist

function exitDistance(grid) {
  const q = [];
  const dist = [];
  grid.forEach((row, r) => {
    dist.push([]);
    row.forEach((v, c) => {
      dist[r].push(v ? -1 : 0);
      if (v === 0) {
        q.push([r, c]);
      }
    });
  });
  for (const [r, c] of q) {
    const d = dist[r][c] + 1;
    for (const [y, x] of [
      [r + 1, c], [r - 1, c],
      [r, c + 1], [r, c - 1],
    ]) {
      if (dist[y]?.[x] !== -1) {
        continue;
      }
      dist[y][x] = d;
      q.push([y, x]);
    }
  }
  return dist;
}

var steps = [][2]int{
	{1, 0}, {-1, 0},
	{0, 1}, {0, -1},
}

func exitDistance(
	grid [][]int,
) [][]int {
	h := len(grid)
	w := len(grid[0])
	dist := make([][]int, h)
	q := [][2]int{}
	for r := range grid {
		dist[r] = make([]int, w)
		for c := range grid[r] {
			dist[r][c] = -1
			if grid[r][c] == 0 {
				dist[r][c] = 0
				q = append(q,
					[2]int{r, c})
			}
		}
	}
	for i := 0; i < len(q); i++ {
		r, c := q[i][0], q[i][1]
		d := dist[r][c] + 1
		for _, s := range steps {
			y, x := r+s[0], c+s[1]
			if y < 0 || y >= h ||
				x < 0 || x >= w ||
				dist[y][x] != -1 {
				continue
			}
			dist[y][x] = d
			q = append(q,
				[2]int{y, x})
		}
	}
	return dist
}