迷宫问题(bfs)

 import java.util.LinkedList;
 import java.util.Queue;
 import java.util.Stack;

 public class BFS
 {
     private static final int M=3;//代表行
     private static final int N=3;//代表列

     int destX=1;
     int destY=0;

     //int[][] maze={{0,0,1,1},{0,0,0,1},{1,1,0,1},{0,0,0,0}};//迷宫布局,1表示障碍物
     int[][] maze={{0,0,0},{0,1,0},{0,0,0}};//迷宫布局,1表示障碍物
     int[][] visit=new int[M][N];//标记是否已经访问过
     int[][] stepArr={{-1,0},{1,0},{0,-1},{0,1}};//表示走路的方向：上下左右

     class Node
     {
         int x,y;//表示当前位置的坐标
         int step;
         int preX,preY;

         Node(int x,int y,int preX,int preY,int step)
         {
             this.x=x;//表示当前位置的横坐标
             this.y=y;//表示当前位置的纵坐标
             this.preX=preX;//表示当前位置前一步的横坐标
             this.preY=preY;//表示当前位置前一步的纵坐标
             this.step=step;//表示行走的路程
         }
     }

     public boolean bfs()
     {
         Node node=new Node(0,0,-1,-1,0);//起始位置
         Queue<Node> queue=new LinkedList<Node>();//LinkedList类实现了Queue接口
         Stack<Node> stack=new Stack<Node>();

         queue.offer(node);//插入node

         while(!queue.isEmpty())
         {
             Node head=queue.poll();//推出队列头

             stack.push(head); //用于保存路径
             visit[head.x][head.y] = 1;  //表示当前位置已被访问，防止两个坐标循环访问
             for(int i = 0; i < 4; i++){  //这里的4表示4张方向
                 int x = head.x + stepArr[i][0];
                 int y = head.y + stepArr[i][1];
                 //exit
                 if(x ==destX && y == destY && maze[x][y] == 0 && visit[x][y] == 0){ //表示找到目的地
                     //打印路径
                     Node top = stack.pop();
                     System.out.println("steps:" + (top.step + 1)); //此处得出的路径是最短路径，因为是queue中保存了每一种可能
                     System.out.println("the path:");
                     System.out.println((M - 1) + "," + (N - 1));
                     System.out.println(top.x + "," + top.y);
                     int preX = top.preX;
                     int preY = top.preY;
                     while(!stack.isEmpty()){
                         top = stack.pop();
                         if (preX == top.x && preY == top.y) { // 因为队列中保存了每一次的各种可能，故需要与之前保存的点进行验证
                             System.out.println(preX + "," + preY);
                             preX = top.preX;
                             preY = top.preY;
                         }  

                     }
                     return true;
                 }
                 //bfs
                 if(x >= 0 && x < M && y >= 0 && y < N &&maze[x][y] == 0 && visit[x][y] == 0){
                     Node newNode = new Node(x, y, head.x, head.y, head.step + 1);
                     queue.offer(newNode);
                 }
             }

         }
         return false;
     }

     public static void main(String[] args)
     {
         BFS b=new BFS();
         if (b.bfs()==false)
         {
             System.out.println("Fail!");
         }
     }

 }

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

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