幅優先探索 (BFS) でグリッドの島を数える

from collections import deque
STEPS = ((1, 0), (-1, 0),
         (0, 1), (0, -1))
def sink(g, r, c):
    h, w = len(g), len(g[0])
    g[r][c] = "0"
    q = deque([(r, c)])
    while q:
        y, x = q.popleft()
        for dy, dx in STEPS:
            a = y + dy
            b = x + dx
            if not 0 <= a < h:
                continue
            if not 0 <= b < w:
                continue
            if g[a][b] == "1":
                g[a][b] = "0"
                q.append((a, b))
def count_islands(grid):
    count = 0
    w = len(grid[0])
    for r in range(len(grid)):
        row = grid[r]
        for c in range(w):
            if row[c] == "1":
                count += 1
                sink(grid, r, c)
    return count

const STEPS = [[1, 0], [-1, 0],
  [0, 1], [0, -1]];
function sink(g, r, c) {
  g[r][c] = "0";
  const q = [[r, c]];
  let i = 0;
  while (i < q.length) {
    const [y, x] = q[i++];
    for (const d of STEPS) {
      const a = y + d[0];
      const b = x + d[1];
      // 外側は undefined になる
      if (g[a]?.[b] !== "1") {
        continue;
      }
      g[a][b] = "0";
      q.push([a, b]);
    }
  }
}
function countIslands(grid) {
  let count = 0;
  grid.forEach((row, r) => {
    row.forEach((v, c) => {
      if (v !== "1") return;
      count++;
      sink(grid, r, c);
    });
  });
  return count;
}

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

func sink(
	g [][]string, r, c int,
) {
	h, w := len(g), len(g[0])
	g[r][c] = "0"
	q := [][2]int{{r, c}}
	for len(q) > 0 {
		p := q[0]
		q = q[1:]
		for _, d := range steps {
			a := p[0] + d[0]
			b := p[1] + d[1]
			if a < 0 || a >= h {
				continue
			}
			if b < 0 || b >= w {
				continue
			}
			if g[a][b] != "1" {
				continue
			}
			g[a][b] = "0"
			next := [2]int{a, b}
			q = append(q, next)
		}
	}
}

func countIslands(
	grid [][]string,
) int {
	count := 0
	for r := range grid {
		for c := range grid[r] {
			if grid[r][c] == "1" {
				count++
				sink(grid, r, c)
			}
		}
	}
	return count
}