EF-T08: Nearest declared grid exit

from collections import deque

def nearest_exit(grid, start, exits):
    if not grid or not grid[0] or any(len(row) != len(grid[0]) for row in grid):
        raise ValueError("grid must be nonempty and rectangular")
    if any(cell not in (0, 1) for row in grid for cell in row):
        raise ValueError("cells must be 0 or 1")
    rows, cols = len(grid), len(grid[0])

    def valid_open(point):
        return (len(point) == 2 and 0 <= point[0] < rows and 0 <= point[1] < cols
                and grid[point[0]][point[1]] == 0)

    if not valid_open(start) or any(not valid_open(exit_point) for exit_point in exits):
        raise ValueError("start and exits must be in-bounds open cells")
    targets = {tuple(exit_point) for exit_point in exits}
    queue = deque([(start[0], start[1], 0)])
    seen = {(start[0], start[1])}
    while queue:
        row, col, distance = queue.popleft()
        if (row, col) in targets:
            return distance
        for row_step, col_step in ((1,0),(-1,0),(0,1),(0,-1)):
            next_row, next_col = row + row_step, col + col_step
            if (0 <= next_row < rows and 0 <= next_col < cols
                    and grid[next_row][next_col] == 0
                    and (next_row, next_col) not in seen):
                seen.add((next_row, next_col))
                queue.append((next_row, next_col, distance + 1))
    return -1

import java.util.ArrayDeque;
import java.util.HashSet;
import java.util.List;
import java.util.Queue;
import java.util.Set;

final class TransferT08 {
    record Point(int row, int col) {}
    record State(int row, int col, int distance) {}

    static int nearestExit(int[][] grid, Point start, List<Point> exits) {
        if (grid.length == 0 || grid[0].length == 0) throw new IllegalArgumentException("empty grid");
        int rows = grid.length;
        int cols = grid[0].length;
        for (int[] row : grid) {
            if (row.length != cols) throw new IllegalArgumentException("ragged grid");
            for (int cell : row) if (cell != 0 && cell != 1) throw new IllegalArgumentException("nonbinary cell");
        }
        if (!validOpen(grid, start)) throw new IllegalArgumentException("invalid start");
        for (Point exit : exits) if (!validOpen(grid, exit)) throw new IllegalArgumentException("invalid exit");
        Set<Point> targets = new HashSet<>(exits);
        boolean[][] seen = new boolean[rows][cols];
        Queue<State> queue = new ArrayDeque<>();
        seen[start.row()][start.col()] = true;
        queue.add(new State(start.row(), start.col(), 0));
        int[][] directions = {{1,0},{-1,0},{0,1},{0,-1}};
        while (!queue.isEmpty()) {
            State state = queue.remove();
            if (targets.contains(new Point(state.row(), state.col()))) return state.distance();
            for (int[] direction : directions) {
                int row = state.row() + direction[0];
                int col = state.col() + direction[1];
                if (row >= 0 && row < rows && col >= 0 && col < cols && grid[row][col] == 0 && !seen[row][col]) {
                    seen[row][col] = true;
                    queue.add(new State(row, col, state.distance() + 1));
                }
            }
        }
        return -1;
    }

    private static boolean validOpen(int[][] grid, Point point) {
        return point.row() >= 0 && point.row() < grid.length && point.col() >= 0
            && point.col() < grid[0].length && grid[point.row()][point.col()] == 0;
    }
}