Minutes until every orange rots

from collections import deque

def oranges_rotting(grid):
    rows, cols = len(grid), len(grid[0])
    state = [list(row) for row in grid]
    q = deque((r, c) for r in range(rows) for c in range(cols) if state[r][c] == '2')
    fresh = sum(row.count('1') for row in state)
    minutes = 0
    while q and fresh:
        for _ in range(len(q)):                 # one ring: everything that rotted last minute
            i, j = q.popleft()
            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 state[a][b] == '1':
                    state[a][b] = '2'           # rots now: never queued twice
                    fresh -= 1
                    q.append((a, b))
        minutes += 1
    return -1 if fresh else minutes

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

int solve(const std::vector<std::string>& grid) {
    std::vector<std::string> state = grid;
    const int rows = state.size(), cols = state[0].size();
    const int dr[] = {1, -1, 0, 0}, dc[] = {0, 0, 1, -1};
    std::vector<std::pair<int, int>> ring;
    int fresh = 0;
    for (int r = 0; r < rows; ++r)
        for (int c = 0; c < cols; ++c) {
            if (state[r][c] == '2') ring.push_back({r, c});
            else if (state[r][c] == '1') ++fresh;
        }
    int minutes = 0;
    while (!ring.empty() && fresh > 0) {
        std::vector<std::pair<int, int>> next;          // the ring that rots this minute
        for (auto [i, j] : ring)
            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 && state[a][b] == '1') {
                    state[a][b] = '2';
                    --fresh;
                    next.push_back({a, b});
                }
            }
        ring.swap(next);
        ++minutes;
    }
    return fresh > 0 ? -1 : minutes;
}

class Solution {
    public int orangesRotting(String[] grid) {
        int rows = grid.length, cols = grid[0].length();
        char[][] state = new char[rows][];
        for (int r = 0; r < rows; r++) state[r] = grid[r].toCharArray();
        int[] dr = {1, -1, 0, 0}, dc = {0, 0, 1, -1};
        java.util.ArrayDeque<int[]> q = new java.util.ArrayDeque<>();
        int fresh = 0;
        for (int r = 0; r < rows; r++)
            for (int c = 0; c < cols; c++) {
                if (state[r][c] == '2') q.add(new int[]{r, c});
                else if (state[r][c] == '1') fresh++;
            }
        int minutes = 0;
        while (!q.isEmpty() && fresh > 0) {
            for (int k = q.size(); k > 0; k--) {        // one ring: last minute's rot
                int[] cell = q.poll();
                for (int d = 0; d < 4; d++) {
                    int a = cell[0] + dr[d], b = cell[1] + dc[d];
                    if (a >= 0 && a < rows && b >= 0 && b < cols && state[a][b] == '1') {
                        state[a][b] = '2';
                        fresh--;
                        q.add(new int[]{a, b});
                    }
                }
            }
            minutes++;
        }
        return fresh > 0 ? -1 : minutes;
    }
}

function orangesRotting(grid) {
  const rows = grid.length, cols = grid[0].length;
  const state = grid.map(row => [...row]);
  let q = [], fresh = 0;
  for (let r = 0; r < rows; r++) for (let c = 0; c < cols; c++) {
    if (state[r][c] === '2') q.push([r, c]);
    else if (state[r][c] === '1') fresh++;
  }
  let minutes = 0;
  while (q.length && fresh) {
    const next = [];                             // the ring that rots this minute
    for (const [i, j] of q) {
      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 && state[a][b] === '1') {
          state[a][b] = '2';
          fresh--;
          next.push([a, b]);
        }
      }
    }
    q = next;
    minutes++;
  }
  return fresh ? -1 : minutes;
}

fn solve(grid: &[&str]) -> i64 {
    let mut state: Vec<Vec<u8>> = grid.iter().map(|row| row.as_bytes().to_vec()).collect();
    let (rows, cols) = (state.len(), state[0].len());
    let mut ring = Vec::new();
    let mut fresh = 0;
    for r in 0..rows {
        for c in 0..cols {
            match state[r][c] {
                b'2' => ring.push((r, c)),
                b'1' => fresh += 1,
                _ => {}
            }
        }
    }
    let mut minutes = 0;
    while !ring.is_empty() && fresh > 0 {
        let mut next = Vec::new();                      // the ring that rots this minute
        for &(i, j) in &ring {
            let mut around = Vec::with_capacity(4);
            if i > 0 { around.push((i - 1, j)); }
            if i + 1 < rows { around.push((i + 1, j)); }
            if j > 0 { around.push((i, j - 1)); }
            if j + 1 < cols { around.push((i, j + 1)); }
            for (a, b) in around {
                if state[a][b] == b'1' {
                    state[a][b] = b'2';
                    fresh -= 1;
                    next.push((a, b));
                }
            }
        }
        ring = next;
        minutes += 1;
    }
    if fresh > 0 { -1 } else { minutes }
}

import qualified Data.Set as S

-- Spread from every rotten orange at once, one ring per minute.
solve :: [String] -> Int
solve grid = go 0 rotten (S.fromList fresh0)
  where
    cells ch = [(r, c) | (r, row) <- zip [0 :: Int ..] grid, (c, x) <- zip [0 :: Int ..] row, x == ch]
    rotten = cells '2'
    fresh0 = cells '1'
    go t ring fresh
      | S.null fresh = t
      | null next = -1
      | otherwise = go (t + 1) next (foldr S.delete fresh next)
      where
        next = S.toList (S.fromList [q | (r, c) <- ring, q <- [(r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)], q `S.member` fresh])