迷宫问题(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的话只能判断能否走出迷宫，并不能知道所走路径是否为最短路径。