迷宫问题(bfs)

 1 import java.util.LinkedList;
 2 import java.util.Queue;
 3 import java.util.Stack;
 4
 5 public class BFS
 6 {
 7     private static final int M=3;//代表行
 8     private static final int N=3;//代表列
 9
10     int destX=1;
11     int destY=0;
12
13     //int[][] maze={{0,0,1,1},{0,0,0,1},{1,1,0,1},{0,0,0,0}};//迷宫布局,1表示障碍物
14     int[][] maze={{0,0,0},{0,1,0},{0,0,0}};//迷宫布局,1表示障碍物
15     int[][] visit=new int[M][N];//标记是否已经访问过
16     int[][] stepArr={{-1,0},{1,0},{0,-1},{0,1}};//表示走路的方向：上下左右
17
18
19
20     class Node
21     {
22         int x,y;//表示当前位置的坐标
23         int step;
24         int preX,preY;
25
26         Node(int x,int y,int preX,int preY,int step)
27         {
28             this.x=x;//表示当前位置的横坐标
29             this.y=y;//表示当前位置的纵坐标
30             this.preX=preX;//表示当前位置前一步的横坐标
31             this.preY=preY;//表示当前位置前一步的纵坐标
32             this.step=step;//表示行走的路程
33         }
34     }
35
36     public boolean bfs()
37     {
38         Node node=new Node(0,0,-1,-1,0);//起始位置
39         Queue<Node> queue=new LinkedList<Node>();//LinkedList类实现了Queue接口
40         Stack<Node> stack=new Stack<Node>();
41
42         queue.offer(node);//插入node
43
44         while(!queue.isEmpty())
45         {
46             Node head=queue.poll();//推出队列头
47
48             stack.push(head); //用于保存路径
49             visit[head.x][head.y] = 1;  //表示当前位置已被访问，防止两个坐标循环访问
50             for(int i = 0; i < 4; i++){  //这里的4表示4张方向
51                 int x = head.x + stepArr[i][0];
52                 int y = head.y + stepArr[i][1];
53                 //exit
54                 if(x ==destX && y == destY && maze[x][y] == 0 && visit[x][y] == 0){ //表示找到目的地
55                     //打印路径
56                     Node top = stack.pop();
57                     System.out.println("steps:" + (top.step + 1)); //此处得出的路径是最短路径，因为是queue中保存了每一种可能
58                     System.out.println("the path:");
59                     System.out.println((M - 1) + "," + (N - 1));
60                     System.out.println(top.x + "," + top.y);
61                     int preX = top.preX;
62                     int preY = top.preY;
63                     while(!stack.isEmpty()){
64                         top = stack.pop();
65                         if (preX == top.x && preY == top.y) { // 因为队列中保存了每一次的各种可能，故需要与之前保存的点进行验证
66                             System.out.println(preX + "," + preY);
67                             preX = top.preX;
68                             preY = top.preY;
69                         }
70
71                     }
72                     return true;
73                 }
74                 //bfs
75                 if(x >= 0 && x < M && y >= 0 && y < N &&maze[x][y] == 0 && visit[x][y] == 0){
76                     Node newNode = new Node(x, y, head.x, head.y, head.step + 1);
77                     queue.offer(newNode);
78                 }
79             }
80
81         }
82         return false;
83     }
84
85
86     public static void main(String[] args)
87     {
88         BFS b=new BFS();
89         if (b.bfs()==false)
90         {
91             System.out.println("Fail!");
92         }
93     }
94
95
96
97
98 }

利用bfs可求出迷宫的最短路径。

如果使用dfs的话只能判断能否走出迷宫，并不能知道所走路径是否为最短路径。