【算法题集锦之三】--迷宫的随机生成和路径搜索

这个题目和数据结构---图有关，由于我对图掌握的不是很熟悉，所以写这篇博客来加深自己的理解。

迷宫的随机生成和路径搜索主要和图的遍历有关，一般来说图的遍历主要有两种方式：1、深度优先遍历（DFS）2、广度优先遍历（BFS）

两种遍历方式都很好理解，就说说深度优先遍历：

深度优先遍历，顾名思义，就是尽可能往深处遍历，访问到一个节点时，搜索这个节点没有被访问过的相邻节点，选择一个继续做同样的操作，直到没有邻节点为止再回溯到上一个访问的节点，并选择另外的邻节点。

可以这样描述深度遍历：

（1）访问顶点v；

（2）从v的未被访问的邻接点中选取一个顶点w，重复第一步，如果v没有未访问的邻接点，回溯至上一顶点；

（3）重复上述两步，直至图中所有和v有路径相通的顶点都被访问到。

例如上图，一个可能的遍历顺序就是1-->2-->5-->6-->3-->7-->8-->4-->9-->10。

那么，迷宫的生成和路径搜索与图的遍历有什么关系呢？

假设有如下一个图：

试着对这个图进行深度优先遍历并把遍历的轨迹记录下来，如下图。

遍历顺序依次为 1--->2--->6---->10---->9---->5----->13----->14----->15----->11----->12-----16---->8----->7----->3---->4，

是不是有点迷宫的样子了呢？但是上面这个经过遍历生成的路径图还不能完全算一个迷宫，因为还缺少了“墙”，补上即可成为一个完整的迷宫，如下图：

上图中蓝色的节点为墙，在遍历过程中将点之间的墙“抹掉”--即空白的格子，这样就可形成一个完整的迷宫，如上图。

怎么样，是不是就是一个迷宫了，注意到遍历一次后任意两点之间都可以找到一条路，所以迷宫的出口和入口只需要从外围的点任选两个即可（如上图中选择的是1旁边的和16旁边的点）。

经过上面的分析，我们就知道该怎么生成一个迷宫了。

1、首先初始化迷宫的雏形，即一个矩形图阵，并为图的每个节点旁边都添加上“墙”，如下图：

2、然后对图中的非“墙”节点进行遍历（深度优先或广度优先都行），为了能够生成随机的迷宫，我们可以在遍历过程过适当的做一些随机的操作（代码中会说明），每次遍历时即打通当前遍历的点与上一个点之间的“墙”

3、遍历完所有的点即可生成一个迷宫，然后再选择出口与入口，一个完整的迷宫就形成了。

至于迷宫的路径搜索，那就完全是图的深度遍历了，大概过程如下。

（1）从迷宫起点节点V开始访问

（2）访问这个节点V，标记为可行的路径；

（3）从v的未被访问的非"墙"邻接点中选取一个顶点w，重复第二步。如果v没有未访问的非"墙"邻接点，把这个节点的可行路径标记移除，回溯至上一节点；

（4）重复上述第（2）、（3）步，直至遍历到迷宫的出口节点。

废话不多说，代码才是正道（以一个二维数组来表示迷宫）：

 
   [java]  
   view plaincopy
package test;  
  
import java.util.ArrayList;  
import java.util.List;  
import java.util.Random;  
import java.util.Stack;  
  
public class Maze {  
  
    /** 
     * 随机生成迷宫 
     * @param size 
     * @return 
     */  
    public static Point[][] createMaze(int size){  
          
        int realSize = 2 * size + 1;  
        Point[][] maze = new Point[realSize][realSize];  
        //初始化迷宫雏形  
        for(int i = 0; i < realSize; i ++){  
              
            for(int j = 0; j < realSize; j ++){  
                Point p = new Point();  
                if(i % 2 == 0){  
                      
                    p.value = 1;  
                      
                }else{  
                      
                    if(j % 2 == 0){  
                          
                        p.value = 1;  
                          
                    } else{  
                          
                        p.value = 0;  
                          
                    }  
                }  
                p.x = i;  
                p.y = j;  
                maze[i][j] = p;  
            }  
        }  
        // 保存轨迹  
        List<Point> trace = new ArrayList<Point>();  
        Point p = maze[1][1];  
        List<Point> tmpList = new ArrayList<Point>();  
        while(trace.size() < size * size){  
              
            tmpList.clear();  
            // 如果没有访问过，设置为访问过  
            if(!p.visited){  
                  
                p.visited = true;  
                // 加入到轨迹中  
                trace.add(p);  
            }  
            //依次查看上下左右四个方向的节点是否被访问过，如果没有访问过，加入列表中  
            // 上  
            if(p.x - 2 > 0) {  
                  
                Point upPoint = maze[p.x - 2][p.y];  
                if(!upPoint.visited)  
                    tmpList.add(upPoint);  
                  
            }  
            // 下  
            if(p.x + 2 < realSize){  
                  
                Point downPoint = maze[p.x + 2][p.y];  
                if(!downPoint.visited)  
                    tmpList.add(downPoint);  
            }  
            // 左  
            if(p.y - 2 > 0){  
                  
                Point leftPoint = maze[p.x][p.y - 2];  
                if(!leftPoint.visited)  
                    tmpList.add(leftPoint);  
            }  
            // 右  
            if(p.y + 2 < realSize){  
                  
                Point rightPoint = maze[p.x][p.y + 2];  
                if(!rightPoint.visited)  
                    tmpList.add(rightPoint);  
            }  
            // 如果上下左右还有点没有访问  
            if(tmpList.size() != 0){  
              
                // 随机取一个邻点，这样就可以随机生成路径达到随机生成迷宫的目的  
                Point nextPoint = tmpList.get(new Random().nextInt(tmpList.size()));  
                // 打通与邻点的“墙”  
                maze[(p.x + nextPoint.x) / 2][(p.y + nextPoint.y) / 2].value = 0;  
                // 设置这个邻点为下一个访问点  
                p = nextPoint;  
            } else{  
                // 如果没有邻点，从之前轨迹中的点中随机取一个，也是为了随机生成迷宫  
                p = trace.get(new Random().nextInt(trace.size()));  
            }  
              
        }  
        return maze;  
    }  
      
    public static Point[][] search(Point[][] maze, Point enterPoint, Point exitPoint){  
          
        int realSize = maze.length;  
        // 保存轨迹  
        Stack<Point> trace = new Stack<Point>();  
        // 出发点  
        Point p = enterPoint;  
        boolean hasFind = false;  
        do{  
            // 如果没有访问过，设置为访问过  
            if(!p.visited){  
                  
                p.visited = true;  
                // 设置value为2（表示可行的路径  
                p.value = 2;  
                // 如果到了终点，中断  
                if(p == exitPoint){  
                    hasFind = true;  
                    break;  
                }  
                // 加入到轨迹中  
                trace.push(p);  
                  
            }  
            Point nextPoint = null;  
            //依次查看上下左右四个方向的节点是否可以走  
            // 上  
            if(p.x - 1 > 0 && maze[p.x - 1][p.y].value == 0 && !maze[p.x-1][p.y].visited) {  
                  
                nextPoint = maze[p.x - 1][p.y];  
            }  
            // 下  
            else if(p.x + 1 < realSize && maze[p.x + 1][p.y].value == 0 && !maze[p.x+1][p.y].visited){  
                  
                nextPoint = maze[p.x + 1][p.y];  
            }  
            // 左  
            else if(p.y - 1 > 0 && maze[p.x][p.y - 1].value == 0 && !maze[p.x][p.y - 1].visited){  
                  
                nextPoint = maze[p.x][p.y - 1];  
            }  
            // 右  
            else if(p.y + 1 < realSize && maze[p.x][p.y + 1].value == 0 && !maze[p.x][p.y + 1].visited){  
                  
                nextPoint = maze[p.x][p.y + 1];  
            }   
            // 如果上下左右有节点可以走  
            if(nextPoint != null){  
                // 设置这个邻点为下一个访问点  
                p = nextPoint;  
            } else{  
                // 如果没有邻点，回退到上一个节点  
                // 改变value  
                p.value = 0;  
                p = trace.pop();  
            }  
              
        } while(!trace.isEmpty());  
        if(hasFind)  
            System.out.println("找到路径");  
        else  
            System.out.println("没找到路径");  
        return maze;  
    }  
    public static void main(String[] args) {  
          
        int size = 5;  
        int realSize = size * 2 + 1;  
        // 生成迷宫  
        Point[][] maze = createMaze(size);  
          
        // 指定迷宫出口、入口  
        // 入口  
        Point enterPoint = maze[1][0];  
        // 设置入口的值为0（表示可通）  
        enterPoint.value = 0;  
        // 出口  
        Point exitPoint = maze[realSize - 2][realSize - 1];  
        // 设置出口的值为0（表示可通）  
        exitPoint.value = 0;  
          
        // 输出迷宫  
        for(int i = 0; i < realSize; i ++){  
              
            for(int j = 0; j < realSize; j ++){  
                  
                System.out.print(maze[i][j].value + " ");  
                // 重置每个点的访问性  
                maze[i][j].visited = false;  
            }  
            System.out.println();  
        }  
        // 搜索出口  
        maze = search(maze, enterPoint, exitPoint);  
        System.out.println();  
        for(int i = 0; i < realSize; i ++){  
              
            for(int j = 0; j < realSize; j ++){  
                  
                System.out.print(maze[i][j].value + " ");  
            }  
            System.out.println();  
        }  
    }  
      
    static class Point{  
        public int x;  
        public int y;  
        public int value;  
        boolean visited = false;  
    }  
}  