Distance to the nearest zero

from collections import deque

def nearest_zero(mat):
    rows, cols = len(mat), len(mat[0])
    dist = [[-1] * cols for _ in range(rows)]
    q = deque()
    for r in range(rows):
        for c in range(cols):
            if mat[r][c] == 0:
                dist[r][c] = 0               # every zero starts in the queue
                q.append((r, c))
    while q:
        r, c = q.popleft()
        for a, b in ((r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)):
            if 0 <= a < rows and 0 <= b < cols and dist[a][b] == -1:
                dist[a][b] = dist[r][c] + 1  # first reached = from the nearest zero
                q.append((a, b))
    return dist

#include <queue>
#include <utility>
#include <vector>

std::vector<std::vector<int>> solve(const std::vector<std::vector<int>>& mat) {
    const int rows = mat.size(), cols = mat[0].size();
    std::vector<std::vector<int>> dist(rows, std::vector<int>(cols, -1));
    std::queue<std::pair<int, int>> q;
    for (int r = 0; r < rows; ++r)
        for (int c = 0; c < cols; ++c)
            if (mat[r][c] == 0) { dist[r][c] = 0; q.push({r, c}); }   // all zeros first
    const int dr[] = {1, -1, 0, 0}, dc[] = {0, 0, 1, -1};
    while (!q.empty()) {
        auto [r, c] = q.front();
        q.pop();
        for (int k = 0; k < 4; ++k) {
            int a = r + dr[k], b = c + dc[k];
            if (a >= 0 && b >= 0 && a < rows && b < cols && dist[a][b] == -1) {
                dist[a][b] = dist[r][c] + 1;
                q.push({a, b});
            }
        }
    }
    return dist;
}

import java.util.*;

class Solution {
    public int[][] nearestZero(int[][] mat) {
        int rows = mat.length, cols = mat[0].length;
        int[][] dist = new int[rows][cols];
        ArrayDeque<int[]> q = new ArrayDeque<>();
        for (int r = 0; r < rows; r++)
            for (int c = 0; c < cols; c++) {
                dist[r][c] = mat[r][c] == 0 ? 0 : -1;
                if (mat[r][c] == 0) q.add(new int[]{r, c});      // all zeros first
            }
        int[] dr = {1, -1, 0, 0}, dc = {0, 0, 1, -1};
        while (!q.isEmpty()) {
            int[] cell = q.poll();
            for (int k = 0; k < 4; k++) {
                int a = cell[0] + dr[k], b = cell[1] + dc[k];
                if (a >= 0 && b >= 0 && a < rows && b < cols && dist[a][b] == -1) {
                    dist[a][b] = dist[cell[0]][cell[1]] + 1;
                    q.add(new int[]{a, b});
                }
            }
        }
        return dist;
    }
}

function nearestZero(mat) {
  const rows = mat.length, cols = mat[0].length;
  const dist = Array.from({ length: rows }, () => new Array(cols).fill(-1));
  const q = [];
  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) if (mat[r][c] === 0) { dist[r][c] = 0; q.push([r, c]); }
  for (let head = 0; head < q.length; head++) {
    const [r, c] = q[head];
    for (const [a, b] of [[r + 1, c], [r - 1, c], [r, c + 1], [r, c - 1]]) {
      if (a >= 0 && b >= 0 && a < rows && b < cols && dist[a][b] === -1) {
        dist[a][b] = dist[r][c] + 1;           // reached from the nearest zero
        q.push([a, b]);
      }
    }
  }
  return dist;
}

use std::collections::VecDeque;

fn solve<const C: usize>(mat: &[[i64; C]]) -> Vec<Vec<i64>> {
    let rows = mat.len();
    let mut dist = vec![vec![-1i64; C]; rows];
    let mut q = VecDeque::new();
    for r in 0..rows {
        for c in 0..C {
            if mat[r][c] == 0 {
                dist[r][c] = 0;                          // all zeros first
                q.push_back((r, c));
            }
        }
    }
    while let Some((r, c)) = q.pop_front() {
        let around = [(r + 1, c), (r.wrapping_sub(1), c), (r, c + 1), (r, c.wrapping_sub(1))];
        for (a, b) in around {
            if a < rows && b < C && dist[a][b] == -1 {
                dist[a][b] = dist[r][c] + 1;
                q.push_back((a, b));
            }
        }
    }
    dist
}

import qualified Data.Map.Strict as M
import Data.Sequence (Seq (..), (|>))
import qualified Data.Sequence as Q

solve :: [[Int]] -> [[Int]]
solve mat = [[dist M.! (r, c) | c <- [0 .. cols - 1]] | r <- [0 .. rows - 1]]
  where
    rows = length mat
    cols = length (head mat)
    zeros = [(r, c) | (r, row) <- zip [0 ..] mat, (c, 0) <- zip [0 ..] row]
    -- every zero starts in the queue at distance 0
    dist = bfs (Q.fromList zeros) (M.fromList [(z, 0) | z <- zeros])
    bfs Empty d = d
    bfs ((r, c) :<| q) d =
      let next = [p | p@(a, b) <- [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)],
                      a >= 0, b >= 0, a < rows, b < cols, not (M.member p d)]
          d' = foldr (\p -> M.insert p (d M.! (r, c) + 1)) d next
      in bfs (foldl (|>) q next) d'