2-BFS

算法思想

算法模板

import java.util.*;

public class Main {
    static int N = 110;
    // g[i][j]表示点（i, j）是否可通过，下标从1开始
    static int[][] g = new int[N][N],
    // d[i][j]表示点 （i, j）距离起点的距离，下标从1开始
        d = new int[N][N];
    static int m, n;
    static Deque<Point> queue = new ArrayDeque<Point>();
    static int count = -1;
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        for(int i = 1; i <= n; i ++ )
            for(int j = 1; j <= m; j ++ )
            {
                g[i][j] = in.nextInt();
                d[i][j] = -1;
            }
        System.out.println(bfs());
        
    }
    
    static int bfs()
    {
        queue.offer(new Point(1, 1));
        d[1][1] = 0;
        // 上下左右四个方向的向量值
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};
        
        while(!queue.isEmpty())
        {
            var point = queue.poll();
            int x = point.x, y = point.y;
            g[x][y] = 1;
            
            for(int i = 0; i < 4; i ++ )
            {
                int newX = x + dx[i], newY = y + dy[i];
                
                // 迷宫边界                
                if(newX >= 1 && newX <= n && newY >= 1 && newY <= m)
                {
                    if(g[newX][newY] == 0 && d[newX][newY] == -1)
                    {
                        d[newX][newY] = d[x][y] + 1;
                        queue.offer(new Point(newX, newY));
                    }
                }
            }
        }
        
        return d[n][m];
    }
}

class Point 
{
    int x, y;
    
    public Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}