迷宫算法（DFS，BFS）

DFS

dfs深度优先，适用于找唯一条路径：也可以找多条路径中最短距离时，当大于10x10或出现的路径较多时，效率较差。会走许多重复的路线

dfs使用标记、回溯解决循环绕圈问题。

    static int n = 110, m = 110, count = 100010;
    static int a[][] = new int[n][m];
    static int b[][] = new int[n][m];  //判断某点是否使用

    public static void dfs(int x, int y, int u){
        if(x == n || y == m) return;
        if(x == n - 1 && y == m - 1){
            count = Math.min(count, u);
            return;
        }
        
        //向右
        if(a[x][y + 1] == 0 && b[x][y + 1] == 0){
            b[x][y + 1] = 1;
            dfs(x, y + 1, u + 1);
            b[x][y + 1] = 0;
        }
        //向下
        if(a[x + 1][y] == 0 && b[x + 1][y] == 0){
            b[x + 1][y] = 1;
            dfs(x + 1, y, u + 1);
            b[x + 1][y] = 0;
        }
        //向左
        if(y > 0 && a[x][y - 1] == 0 && b[x][y - 1] == 0){
            b[x][y - 1] = 1;
            dfs(x, y - 1, u + 1);
            b[x][y - 1] = 0;
        }
        //向上
        if(x > 0 && a[x - 1][y] == 0 && b[x - 1][y] == 0){
            b[x - 1][y] = 1;
            dfs(x - 1, y, u + 1);
            b[x - 1][y] = 0;
        }
    }

简化上面方法

    static int dx[] = new int[]{0, 1, 0, -1}, dy[] = new int[]{1, 0, -1, 0};

    public static void dfs(int x, int y, int u){
        if(x == n || y == m) return;
        if(x == n - 1 && y == m - 1){
            count = Math.min(count, u);
            return;
        }
        for (int i = 0; i < 4; i++) {
            int tx = x + dx[i];
            int ty = y + dy[i];
            if(tx > -1 && ty > -1 &&a[tx][ty] == 0 && b[tx][ty] == 0){
                b[tx][ty] = 1;
                dfs(tx, ty, u + 1);
                b[tx][ty] = 0;
            }
        }
   }

BFS

只有当所有边的权重都相等时（即向西面移动的所消耗的权重相等），才用BFS。
寻找从该点开始距离为 “1” 的可成功到达的点（并记录它到起点的距离），一层一层找。最多枚举所有点位，而bfs会重复枚举相同点位。
这里使用对象数组模拟队列存储坐标。

import java.io.*;
import java.util.*;

public class Main{
    static int n = 110, m = 110;
    static int a[][] = new int[n][m];
    static int d[][] = new int[n][m];

    static int dx[] = new int[]{0, 1, 0, -1}, dy[] = new int[]{1, 0, -1, 0};//向四方移动时坐标变化（右下左上）
    private static PII[] q = new PII[n*m];
    
    public static int bfs(){
        int tt = 0, hh = 0;
        q[0] = new PII(0,0);//初始化起点坐标

        while(hh <= tt){
            PII pii = q[hh++];//获取一个节点的坐标
            for (int i = 0; i < 4; i++) {//枚举这个坐标向四方走
                 int x = pii.getFirst() + dx[i], y = pii.getSecond() + dy[i];
                 if(x > -1 && x < n && y > -1 && y < m && a[x][y] == 0 && d[x][y] == 0){//判断下一坐标是否可用且未使用
                     d[x][y] = d[pii.getFirst()][pii.getSecond()] + 1;//记录将该坐标离起点长短
                     q[++tt] = new PII(x,y);//新起一个对象记录该坐标
                 }
            }
        }
        return d[n-1][m-1];
    }

    public static void main(String []args)throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String nm[] = in.readLine().split(" ");
        n = Integer.parseInt(nm[0]);
        m = Integer.parseInt(nm[1]);

        for(int i = 0; i < n; i++){
            String str[] = in.readLine().split(" ");
            for(int j = 0; j < m; j++)
                a[i][j] = Integer.parseInt(str[j]);
        }
        System.out.print(bfs());

    }
}


class PII{
    private int first;
    private int second;

    public PII() {
    }

    public PII(int first, int second) {
        this.first = first;
        this.second = second;
    }

    public int getFirst() {
        return first;
    }

    public int getSecond() {
        return second;
    }
}