迷宮問題中，有很大一部分可以用BFS來解。解決這類問題可以很大地提升能力與技巧，這篇文章是基於一個簡單例項展開來講的

例題： 
第一行兩個整數n， m，為迷宮的長寬。 
接下來n行，每行m個數為0或1中的一個。0表示這個格子可以通過，1表示不可以。假設你現在已經在迷宮座標(1,1)的地方，即左上角，迷宮的出口在(n,m)。每次移動時只能向上下左右4個方向移動到另外一個可以通過的格子裡，每次移動算一步。資料保證(1,1)，(n,m)可以通過。 
輸出格式 
　　第一行一個數為需要的最少步數K。 
　　第二行K個字元，每個字元∈{U,D,L,R},分別表示上下左右。如果有多條長度相同的最短路徑，選擇在此表示方法下字典序最小的一個。 
　樣例輸入 
Input Sample 1: 
3 3 
0 0 1 
1 0 0 
1 1 0

Input Sample 2: 
3 3 
0 0 0 
0 0 0 
0 0 0 
樣例輸出 
Output Sample 1: 
4 
RDRD

Output Sample 2: 
4 
DDRR

BFS，屬於一種盲目搜尋法，目的是系統地展開並檢查圖中的所有節點，以找尋結果。換句話說，它並不考慮結果的可能位置，徹底地搜尋整張圖，直到找到結果為止。 
虛擬碼

queue.add(起點)；
while(佇列不為空){
    取出隊首點
    if(如果為終點)
        結束
    //不為終點，繼續向下走
    for(方向)
        ...
}

• 下面貼上例題的程式碼

public class maze {

    static
 
 int[][] one = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };//上下左右移動座標的變化
    static String[] nextpath = { "U", "D", "L", "R" };//上下左右移動的表示

    static class point {//點類記錄當前座標，步數，路徑
        int x, y, step;//step表示從出發到當前點經過幾步
        String path;//path表示從出發到當前點經過路徑

        public point(int x, int y, int step, String path) {
            this
 
.x = x;
            this.y = y;
            this.step = step;
            this.path = path;
        }

    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] mazeArray = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                mazeArray[i][j] = in.nextInt();
            }
        }
        bfs(mazeArray, n, m);
    }

    //按字典序較小選擇路徑
    public static boolean comparePath(String A, String B) {
        char[] arrayA = A.toCharArray();
        char[] arrayB = B.toCharArray();
        for (int i = 0, len = A.length(); i < len; i++) {
            if (arrayA[i] < arrayB[i])
                return false;
        }
        return true;
    }

    //判斷點是否出界或被訪問過
    public static boolean validatePoint(int[][] matrix, point a) {
        int n = matrix.length - 1, m = matrix[0].length - 1;
        if (a.x < 0 || a.x > n || a.y < 0 || a.y > m || matrix[a.x][a.y] == 1)
            return false;
        return true;
    }

    //搜尋
    static void bfs(int[][] mazeArray, int n, int m) {
        ArrayList<point> list = new ArrayList<point>();
        list.add(new point(0, 0, 0, ""));//向佇列中加入第一個點
        int minStep = Integer.MAX_VALUE;//最小步數
        String minPath = "";//最短路徑
        while (list.size() != 0) {
            point currentPoint = list.get(0);//當佇列中有點時，取出點比較是否為終點
            list.remove(0);//刪除該點
            if (currentPoint.x == n - 1 && currentPoint.y == m - 1) {
                if (minStep > currentPoint.step) {
                    minStep = currentPoint.step;
                    minPath = currentPoint.path;
                } else if (minStep == currentPoint.step) {
                    if (comparePath(minPath, currentPoint.path)) {
                        minPath = currentPoint.path;
                    }
                }
                continue;

            }
            //如果不是終點，依次嘗試訪問上下左右，並加入佇列繼續迴圈
            for (int i = 0; i < 4; i++) {
                int x = currentPoint.x + one[i][0];
                int y = currentPoint.y + one[i][1];
                int step = currentPoint.step + 1;
                String path = currentPoint.path + nextpath[i];
                point nextPoint = new point(x, y, step, path);
                if (validatePoint(mazeArray, currentPoint)) {
                    list.add(nextPoint);
                    mazeArray[x][y] = 1; //mark as 1 to bypass select next time
                }
            }
        }
        System.out.println(minPath + "\n" + minStep);//迴圈結束輸出最短步數及路徑
        return;
    }

}

執行結果

3 3
0 1 0
0 1 0
0 0 0
DDRR
4

• 如果無通路則會輸出Integer.Max_Value