这个问题可以使用bfs解决

bfs是广度优先搜索,可以从一个点辐射到相邻的点,再从相邻的点出发辐射它相邻的点 , 由于这个特性它还可以用来处理最短路径问题

import java.util.*;
public class bsfTest1 {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int n =sc.nextInt();
        int[][] map = new int[n+2][n+2];
        int[][] vis = new int[n+2][n+2];
        int[][] step = {{0,1},{0,-1},{1,0},{-1,0}};//这个为方向数组
        for (int i = 1; i <=n ; i++) {
            for (int j = 1; j <=n ; j++) {
                map[i][j] = sc.nextInt();
                vis[i][j] = map[i][j];
            }
        }
        dfs(vis,step);
        for (int i = 1; i <=n ; i++) {
            for (int j = 1; j <=n ; j++) {
                if(vis[i][j]!=1){
                    System.out.print(2+" ");
                }else System.out.print(map[i][j]+" ");
                if (j==n) System.out.println();

            }
        }
    }
    public static void dfs(int[][] vis,int[][] step){
        Queue<Integer> qx = new LinkedList<>();
        Queue<Integer> qy = new LinkedList<>();
        qx.add(0);
        qy.add(0);
        vis[0][0] = 1;//标记
        while(!qx.isEmpty()){
            for (int i = 0; i < 4; i++) {
                int x = qx.peek()+step[i][0];
                int y = qy.peek()+step[i][1];
                if(x>=0&&y>=0&&x<vis[0].length&&y<vis[0].length&&vis[x][y]!=1) {
                    qx.add(x);
                    qy.add(y);
                    vis[x][y] = 1;//标记
                }
            }
            qx.poll();
            qy.poll();
        }
    }
}