Count the islands in a grid

def num_islands(grid):
    rows, cols = len(grid), len(grid[0])
    seen = [[False] * cols for _ in range(rows)]
    count = 0
    for r in range(rows):
        for c in range(cols):
            if grid[r][c] != '1' or seen[r][c]:
                continue
            count += 1                          # a new island: flood it so it is never counted again
            seen[r][c] = True
            stack = [(r, c)]
            while stack:
                i, j = stack.pop()
                for a, b in ((i + 1, j), (i - 1, j), (i, j + 1), (i, j - 1)):
                    if 0 <= a < rows and 0 <= b < cols and grid[a][b] == '1' and not seen[a][b]:
                        seen[a][b] = True       # mark on push: no cell enters the stack twice
                        stack.append((a, b))
    return count

#include <string>
#include <utility>
#include <vector>

int solve(const std::vector<std::string>& grid) {
    const int rows = grid.size(), cols = grid[0].size();
    std::vector<std::vector<bool>> seen(rows, std::vector<bool>(cols, false));
    const int dr[] = {1, -1, 0, 0}, dc[] = {0, 0, 1, -1};
    int count = 0;
    for (int r = 0; r < rows; ++r) {
        for (int c = 0; c < cols; ++c) {
            if (grid[r][c] != '1' || seen[r][c]) continue;
            ++count;                                    // a new island: flood it
            seen[r][c] = true;
            std::vector<std::pair<int, int>> stack{{r, c}};
            while (!stack.empty()) {
                auto [i, j] = stack.back();
                stack.pop_back();
                for (int k = 0; k < 4; ++k) {
                    const int a = i + dr[k], b = j + dc[k];
                    if (a >= 0 && a < rows && b >= 0 && b < cols && grid[a][b] == '1' && !seen[a][b]) {
                        seen[a][b] = true;              // mark on push
                        stack.push_back({a, b});
                    }
                }
            }
        }
    }
    return count;
}

class Solution {
    public int numIslands(String[] grid) {
        int rows = grid.length, cols = grid[0].length();
        boolean[][] seen = new boolean[rows][cols];
        int[] dr = {1, -1, 0, 0}, dc = {0, 0, 1, -1};
        java.util.ArrayDeque<int[]> stack = new java.util.ArrayDeque<>();
        int count = 0;
        for (int r = 0; r < rows; r++) {
            for (int c = 0; c < cols; c++) {
                if (grid[r].charAt(c) != '1' || seen[r][c]) continue;
                count++;                                // a new island: flood it
                seen[r][c] = true;
                stack.push(new int[]{r, c});
                while (!stack.isEmpty()) {
                    int[] cell = stack.pop();
                    for (int k = 0; k < 4; k++) {
                        int a = cell[0] + dr[k], b = cell[1] + dc[k];
                        if (a >= 0 && a < rows && b >= 0 && b < cols && grid[a].charAt(b) == '1' && !seen[a][b]) {
                            seen[a][b] = true;          // mark on push
                            stack.push(new int[]{a, b});
                        }
                    }
                }
            }
        }
        return count;
    }
}

function numIslands(grid) {
  const rows = grid.length, cols = grid[0].length;
  const seen = Array.from({ length: rows }, () => new Array(cols).fill(false));
  let count = 0;
  for (let r = 0; r < rows; r++) {
    for (let c = 0; c < cols; c++) {
      if (grid[r][c] !== '1' || seen[r][c]) continue;
      count++;                                  // a new island: flood it
      seen[r][c] = true;
      const stack = [[r, c]];
      while (stack.length) {
        const [i, j] = stack.pop();
        for (const [a, b] of [[i + 1, j], [i - 1, j], [i, j + 1], [i, j - 1]]) {
          if (a >= 0 && a < rows && b >= 0 && b < cols && grid[a][b] === '1' && !seen[a][b]) {
            seen[a][b] = true;                  // mark on push
            stack.push([a, b]);
          }
        }
      }
    }
  }
  return count;
}

fn solve(grid: &[&str]) -> i64 {
    let g: Vec<&[u8]> = grid.iter().map(|row| row.as_bytes()).collect();
    let (rows, cols) = (g.len(), g[0].len());
    let mut seen = vec![vec![false; cols]; rows];
    let mut count = 0;
    for r in 0..rows {
        for c in 0..cols {
            if g[r][c] != b'1' || seen[r][c] {
                continue;
            }
            count += 1;                                 // a new island: flood it
            seen[r][c] = true;
            let mut stack = vec![(r, c)];
            while let Some((i, j)) = stack.pop() {
                let mut next = Vec::with_capacity(4);
                if i > 0 { next.push((i - 1, j)); }
                if i + 1 < rows { next.push((i + 1, j)); }
                if j > 0 { next.push((i, j - 1)); }
                if j + 1 < cols { next.push((i, j + 1)); }
                for (a, b) in next {
                    if g[a][b] == b'1' && !seen[a][b] {
                        seen[a][b] = true;              // mark on push
                        stack.push((a, b));
                    }
                }
            }
        }
    }
    count
}

import qualified Data.Set as S

-- Every unseen land cell starts a new island; flood it before moving on.
solve :: [String] -> Int
solve grid = go (S.toList land) S.empty 0
  where
    land = S.fromList [(r, c) | (r, row) <- zip [0 :: Int ..] grid, (c, ch) <- zip [0 :: Int ..] row, ch == '1']
    go [] _ n = n
    go (p : ps) seen n
      | p `S.member` seen = go ps seen n
      | otherwise = go ps (flood [p] (S.insert p seen)) (n + 1)
    flood [] seen = seen
    flood ((r, c) : st) seen =
      let next = [q | q <- [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)], q `S.member` land, not (q `S.member` seen)]
      in flood (next ++ st) (foldr S.insert seen next)