java的走迷宫问题bfs

以下是Java中使用BFS算法解决走迷宫问题的示例代码：

import java.util.*;

public class MazeBFS {
    static int[][] maze = {{0, 0, 0, 0, 0, 0, 0, 0},
                           {0, 1, 0, 1, 1, 1, 0, 0},
                           {0, 1, 0, 0, 0, 0, 0, 0},
                           {0, 1, 1, 1, 0, 1, 1, 0},
                           {0, 1, 0, 0, 0, 0, 1, 0},
                           {0, 1, 1, 1, 1, 1, 1, 0},
                           {0, 0, 0, 0, 0, 0, 0, 0}};

    static int[][] direction = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};

    public static void main(String[] args) {
        int startX = 1;
        int startY = 1;
        int endX = 5;
        int endY = 6;

        Queue<Node> queue = new LinkedList<>();
        boolean[][] visited = new boolean[maze.length][maze[0].length];

        Node startNode = new Node(startX, startY, 0);
        queue.offer(startNode);
        visited[startX][startY] = true;

        while (!queue.isEmpty()) {
            Node node = queue.poll();
            int x = node.x;
            int y = node.y;
            int step = node.step;

            if (x == endX && y == endY) {
                System.out.println(step);
                break;
            }

            for (int i = 0; i < 4; i++) {
                int nextX = x + direction[i][0];
                int nextY = y + direction[i][1];

                if (nextX >= 0 && nextX < maze.length &&
                    nextY >= 0 && nextY < maze[0].length &&
                    maze[nextX][nextY] == 0 && !visited[nextX][nextY]) {
                    queue.offer(new Node(nextX, nextY, step + 1));
                    visited[nextX][nextY] = true;
                }
            }
        }
    }

    static class Node {
        int x;
        int y;
        int step;

        public Node(int x, int y, int step) {
            this.x = x;
            this.y = y;
            this.step = step;
        }
    }
}

在上述代码中，我们使用了一个Node类来表示迷宫中的每个节点，其中包含了x和y坐标以及当前步数step。我们使用一个队列来进行BFS搜索，并且使用一个二维布尔数组visited来记录每个节点是否已经被访问过。

我们从起点开始，将其加入队列中，并将其visited值设为true。然后不断从队列中取出节点进行搜索，直到队列为空或者找到终点为止。对于每个节点，我们尝试向四个方向扩展，如果扩展出来的节点在迷宫范围内、不是墙、没有被访问过，就将其加入队列中，并将visited值设为true。

最终，如果搜索到了终点，就输出步数并停止搜索。如果队列为空仍然没有找到终点，说明终点不可达。