Matriz Likou 542.01 [mediana]

Antes de buscar la solución, solo pensé en Guangsou desde el principio. Usé mis propios platos reales todos los días para resolver el problema usando Guangsou + Queue. Pero en lugar de buscar desde 1, comenzó desde 0, porque comenzó desde 1. La búsqueda solo puede encontrar la ruta más corta de un punto y, a partir de 0, se puede optimizar cualquier ruta que sea más larga que la ruta actual.

Dada una matriz de 0 y 1, calcule la distancia de cada elemento al 0 más cercano.

La distancia entre dos elementos adyacentes es 1.

Ejemplo 1:
Entrada:

0 0 0
0 1 0
0 0 0
Salida:

0 0 0
0 1 0
0 0 0
Ejemplo 2:
Entrada:

0 0 0
0 1 0
1 1 1
Salida:

0 0 0
0 1 0
1 2 1
Nota:

El número de elementos de una matriz determinada no supera los 10.000.
Al menos un elemento de la matriz dada es 0.
Los elementos de la matriz solo son adyacentes en cuatro direcciones: arriba, abajo, izquierda y derecha.

Fuente: LeetCode
Enlace: https://leetcode-cn.com/problems/01-matrix

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class test542 {
    
    

    public static void main(String[] args) {
    
    
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int[][] s = new int[3][3];
        for (int i = 0; i < 3;i++){
    
    
            try {
    
    
                String[] in = (br.readLine()).split(" ");
                for (int j = 0;j < in.length;j++){
    
    
                    s[i][j] = Integer.parseInt(in[j]);
                }
            } catch (IOException e) {
    
    
                e.printStackTrace();
            }
        }
        System.out.println(Arrays.deepToString(updateMatrix(s)));
    }

    public static int[][] updateMatrix(int[][] matrix){
    
    

        int row = matrix.length, col = matrix[0].length;
        int[][] vector = new int[][]{
    
    {
    
    0, 1}, {
    
    0, -1}, {
    
    1, 0}, {
    
    -1, 0}};

        Queue<int[]> queue = new LinkedList<>();

        for (int i = 0;i < row;i++){
    
    
            for (int j = 0; j < col;j++){
    
    
                if (matrix[i][j] == 0)
                {
    
    
                    //多源广度搜索
                    queue.add(new int[] {
    
    i, j});
                }else{
    
    
                    //将路径长度变为不可达。
                    matrix[i][j] = row + col;
                }
            }
        }

        //访问队列中的节点，直至队列为空。
        while (!queue.isEmpty()){
    
    
            int[] s = queue.poll();

            //访问数组上下左右的邻居
            for (int[] ints : vector) {
    
    
                int x = ints[0] + s[0], y = ints[1] + s[1];

                //判断数组是否越界，并将不是最短路径的节点优化为最短，
                //优化后的节点加入队列，以便优化未被优化的邻居。
                if (x >= 0 && x < row && y >= 0 && y < col
                && matrix[x][y] > matrix[s[0]][s[1]] + 1){
    
    
                    matrix[x][y] = matrix[s[0]][s[1]] + 1;
                    queue.add(new int[] {
    
    x,y});
                }
            }
        }

        return matrix;
    }