迷宫问题的求解(回溯法、深度优先遍历、广度优先遍历)

一、问题介绍

　　有一个迷宫地图，有一些可达的位置，也有一些不可达的位置（障碍、墙壁、边界）。从一个位置到下一个位置只能通过向上（或者向右、或者向下、或者向左）走一步来实现，从起点出发，如何找到一条到达终点的通路。本文将用两种不同的解决思路，四种具体实现来求解迷宫问题。

　　用二维矩阵来模拟迷宫地图，1代表该位置不可达，0代表该位置可达。每走过一个位置就将地图的对应位置标记，以免重复。找到通路后打印每一步的坐标，最终到达终点位置。

　　封装了点Dot，以及深度优先遍历用到的Block，广度优先遍历用到的WideBlock。

private int[][] map = {                           //迷宫地图,1代表墙壁，0代表通路
        {1,1,1,1,1,1,1,1,1,1},
        {1,0,0,1,0,0,0,1,0,1},
        {1,0,0,1,0,0,0,1,0,1},
        {1,0,0,0,0,1,1,0,0,1},
        {1,0,1,1,1,0,0,0,0,1},
        {1,0,0,0,1,0,0,0,0,1},
        {1,0,1,0,0,0,1,0,0,1},
        {1,0,1,1,1,0,1,1,0,1},
        {1,1,0,0,0,0,0,0,0,1},
        {1,1,1,1,1,1,1,1,1,1}
    };
    
    private int mapX = map.length - 1;                //地图xy边界
    
    private int mapY = map[0].length - 1;
    
    private int startX = 1;                           //起点
    
    private int startY = 1;
    
    private int endX = mapX - 1;                      //终点
    
    private int endY = mapY - 1;

　　//内部类，封装一个点
    public class Dot{
        private int x;            //行标
        private int y;            //列标
        
        public Dot(int x , int y) {
            this.x = x;
            this.y = y;
        }
        
        public int getX(){
            return x;
        }
        
        public int getY(){
            return y;
        }
    }
    
    //内部类，封装走过的每一个点,自带方向
    public class Block extends Dot{
        
        private int dir;          //方向,1向上，2向右，3向下，4向左
        
        public Block(int x , int y) {
            super(x , y);
            dir = 1;
        }
        
        public int getDir(){
            return dir;
        }
        
        public void changeDir(){
            dir++;
        }
    }
    
    /*
        广度优先遍历用到的数据结构，它需要一个指向父节点的索引
    */
    public class WideBlock extends Dot{
        private WideBlock parent;
        
        public WideBlock(int x , int y , WideBlock p){
            super(x , y);
            parent = p;
        }
        
        public WideBlock getParent(){
            return parent;
        }
    }

 　

二、回溯法

　　思路：从每一个位置出发，下一步都有四种选择（上右下左），先选择一个方向，如果该方向能够走下去，那么就往这个方向走，当前位置切换为下一个位置。如果不能走，那么换个方向走，如果所有方向都走不了，那么退出当前位置，到上一步的位置去，当前位置切换为上一步的位置。一致这样执行下去，如果当前位置是终点，那么结束。如果走过了所有的路径都没能到达终点，那么无解。下面看代码

private Stack<Block> stack = new Stack<Block>();  //回溯法存储路径的栈

public void findPath1(){
        Block b = new Block(startX,startY);
        stack.push(b);                                //起点进栈  
        while(!stack.empty()){                        //栈空代表所有路径已走完，没有找到通路
            Block t = stack.peek();
            
            int x = t.getX();                         //获取栈顶元素的x
            int y = t.getY();                         //获取栈顶元素的y
            int dir = t.getDir();                     //获取栈顶元素的下一步方向
            
            map[x][y] = 1;                            //把地图上对应的位置标记为1表示是当前路径上的位置，防止往回走
            
            if(t.getX() == endX && t.getY() == endY) {//已达终点
                return ;
            }                     
            
            switch(dir){
                case 1:                                     //向上走一步                           
                    if(x - 1 >= 0 && map[x - 1][y] == 0){   //判断向上走一步是否出界&&判断向上走一步的那个位置是否可达
                        stack.push(new Block(x - 1 , y));   //记录该位置
                    }
                    t.changeDir();                          //改变方向，当前方向已走过
                    continue;                               //进入下一轮循环
                case 2:
                    if(y + 1 <= mapY && map[x][y+1] == 0){
                        stack.push(new Block(x , y + 1));
                    }
                    t.changeDir();
                    continue;
                case 3:
                    if(x + 1 <= mapX && map[x+1][y] == 0){
                        stack.push(new Block(x + 1 , y));
                    }
                    t.changeDir();
                    continue;
                case 4:
                    if(y - 1 >= 0 && map[x][y - 1] == 0){
                        stack.push(new Block(x , y - 1));
                    }
                    t.changeDir();
                    continue;
            }
            t = stack.pop();                                    //dir > 4 当前Block节点已经没有方向可走,出栈
            map[t.getX()][t.getY()] = 0;                        //出栈元素对应的位置已经不再当前路径上，表示可达
            
        }
    }

//打印栈
    public void printStack(){
        int count = 1;
        while(!stack.empty()){
            Block b = stack.pop();
            System.out.print("(" + b.getX() + "," + b.getY() + ") ");
            if(count % 10 == 0)
                System.out.println("");
            count++;
        }
    }

测试结果：

 递归实现：

    private Stack<Block> s = new Stack<Block>();      //回溯法全局辅助栈
　　 private Stack<Block> stack = new Stack<Block>();  //回溯法存储路径的栈

    public void findPath2(){
        if(startX >= 0 && startX <= mapX && startY >= 0 && startY <= mapY && map[startX][startY] == 0){ 
            find(startX , startY);
        }
    }
    private void find(int x , int y){
　　　　　map[x][y] = 1;
        if(x == endX && y == endY) {
            s.push(new Block(x , y));
            while(!s.empty()){
                stack.push(s.pop());
            }
            //return ;               //在此处返回会使后续递归再次寻找路线会经过这里，如果不返回，整个函数执行完毕，所有路径都会被访问到
        }
        s.push(new Block(x , y));if( x - 1 >= 0 && map[x - 1][y] == 0 ){  //可以往上走，那么往上走
            find(x - 1 , y);
        }
        if(x + 1 <= mapX && map[x + 1][y] == 0){ //可以往下走，那么往下走
            find(x + 1 , y);
        }
        if(y - 1 >= 0 && map[x][y - 1] ==0){     //往左
            find(x , y - 1);
        }
        if(y + 1 <= mapY && map[x][y + 1] == 0){
            find(x , y + 1);
        }
        if(!s.empty()){
            s.pop();
        }
    }

测试结果：

三、深度优先遍历

　　思路：和上面的回溯法思想基本一样，能向某个方向走下去就一直向那个方向走，不能走就切换方向，所有方向都不能走了就回到上一层位置。

    private Stack<Dot> stackDeep = new Stack<Dot>();  //深度遍历时用的存储栈
    
    private Stack<Dot> sDeep = new Stack<Dot>();      //深度遍历时用到的辅助栈

　　 public void findPath3() { // 判断起点的合法性
        if (startX >= 0 && startX <= mapX && startY >= 0 && startY <= mapY && map[startX][startY] == 0) {
            deepFirst(startX, startY);
        }
    }
    public void deepFirst(int x, int y) {
        Dot b = new Dot(x, y);
        sDeep.push(b);
　　　　 map[x][y] = 1; // 标记已访问
        if (x == endX && y == endY) {
            while (!sDeep.empty()) {
                stackDeep.push(sDeep.pop());
            }
            //return ;                //此处的return和上一个递归的return一样,如果返回
        }                          

        for (int i = 1; i <= 4; i++) { // 在每个方向上进行尝试
            if (i == 1) { // 上
                if (x - 1 >= 0 && map[x - 1][y] == 0) {
                    deepFirst(x - 1, y);
                }
            } else if (i == 2) { // 右
                if (y + 1 <= mapY && map[x][y + 1] == 0) {
                    deepFirst(x, y + 1);
                }
            } else if (i == 3) { // 下
                if (x + 1 <= mapX && map[x + 1][y] == 0) {
                    deepFirst(x + 1, y);
                }
            } else { // 左
                if (y - 1 >= 0 && map[x][y - 1] == 0) {
                    deepFirst(x, y - 1);
                }
            }
        }
        if(!sDeep.empty()) {
            sDeep.pop(); // 四个方向都已尝试过，并且没成功，退栈
        }
    }

    //打印深度优先遍历的栈
    public void printDeepStack(){
        int count = 1;
        while(!stackDeep.empty()){
            Dot b = stackDeep.pop();
            System.out.print("(" + b.getX() + "," + b.getY() + ") ");
            if(count++ % 10 == 0){
                System.out.println("");
            }
        }
    }

测试结果：

　　栈实现、递归和深度优先遍历，这三者的执行思路是一样的，都可以看做二叉树先根遍历的变体，起点看做根节点，每个选择方向看做一个分叉，四个方向对应四个子节点，如果某个节点四个方向都走不了，那么它就是叶子节点。每走到一个叶子节点就是一条完整的执行路径，只不过不一定到达了终点。按照先根遍历的方式，最终会走完每一条路径，如果在路径中找到了终点，那么记录下这条路径线索。二叉树先根遍历的递归实现对应了上面的递归实现，只不过这里是四叉树，栈实现可以看成先根遍历的非递归算法，而深度优先遍历和先跟遍历本就有异曲同工之妙。

四、广度优先遍历

　　思路：这种方法和前面三种是不同的思路。先从根节点出发，将当前节点的所有可达子节点依次访问，在依次访问子节点的子节点，一直下去直到所有节点被遍历。

    private WideBlock wb;                             //广度遍历的终点节点

    /*
        广度优先遍历
    */
    public void findPath4(){
        wideFirst();
    }
    
    public void wideFirst(){
        WideBlock start = new WideBlock(startX , startY , null);
        Queue<WideBlock> q = new LinkedList<WideBlock>();  
        map[startX][startY] = 1;                       
        q.offer(start);
        while(q.peek() != null){
            WideBlock b = q.poll();
            int x = b.getX();
            int y = b.getY();
            if(x == endX && y == endY){                 //判断当前节点是否已达终点
                wb = b;
                return;
            }
            if (x - 1 >= 0 && map[x - 1][y] == 0) {     //判断当前节点的能否向上走一步，如果能，则将下一步节点加入队列
                q.offer(new WideBlock(x - 1 , y , b));  //子节点入队
                map[x - 1][y] = 1;                      //标记已访问
            }
            if (y + 1 <= mapY && map[x][y + 1] == 0) {  //判断当前节点能否向右走一步
                q.offer(new WideBlock(x , y + 1 , b));
                map[x][y + 1] = 1;
            }
            if (x + 1 <= mapX && map[x + 1][y] == 0) {
                q.offer(new WideBlock(x + 1 , y , b));
                map[x + 1][y] = 1;
            }
            if (y - 1 >= 0 && map[x][y - 1] == 0) {
                q.offer(new WideBlock(x , y - 1 , b));
                map[x][y -1] = 1;
            }
        }
    }


    //打印广度遍历的路径
    public void printWidePath(){
        WideBlock b = wb;
        int count = 1;
        while(b != null){
            System.out.print("(" + b.getX() + "," + b.getY() + ") ");
            b = b.getParent();
            if(count++ % 10 == 0){
                System.out.println("");
            }
        }
    }

测试结果：

　　广度优先遍历找出的路径和上面三种方式的结果不一样，它找出的是最短路径。这种方式是从根节点出发，一层一层的往外遍历，当发现某一层上有终点节点时，遍历结束，此时找到的也一定是最短路径，它和二叉树的层序遍历有异曲同工之妙。

　　本文个人编写，水平有限，如有错误，恳请指出，欢迎评论分享