迷宫：深度优先（DFS）和广度优先（BFS）的简单应用

前言

深度优先算法（DFS）和广度优先算法（BFS）是比较基础的算法，在图论算法中还是很重要的。

深度优先算法（DFS）

算法思想：从一个节点开始沿着一条路径走到底。在上图中从1节点开始，先走到2（当然也可以是3或4），再从2开始继续向下走，因为只有5与2相连，所以到5然后到9。到了9之后以为没有与9相连的了，所以要回退，9-5-2-1，又回到1，这时与1相连的还有3、4没走，选一个接着走到底。

广度优先算法（BFS）

算法思想：从一个节点开始访问所有与这个节点相连的。在上图中从1节点开始，与1相连的有2、3、4，所以先访问2再3再4，把与1相连的访问完了后，在从2，3，4中随便选一个继续这个过程，比如选2，然后访问所有与2相连的（即5）。

实例

走迷宫算是DFS经典的应用了，从入口出发沿着一条路一直走，走不通了就回退，直到走到出口。下面代码是在40x40迷宫中寻路过程。

private void DFSWay(int x,int y) {
        if (x==39&&y==39){
            JOptionPane.showMessageDialog(null,
                    "寻路结束!", "游戏结束", JOptionPane.INFORMATION_MESSAGE);
        }else{
            if (judgeWay(x,y)){
                //向右
                if (x+1<=40) {
                    if (canVisited[x + 1][y]) {
                        Point point = new Point(x + 1, y);
                        pointList.add(point);
                        canVisited[x + 1][y] = false;
                        waitTime();
                        DFSWay(x + 1, y);
                    }
                }
                if (y+1<=40){
                    //向下
                    if (canVisited[x][y+1]){
                        Point point = new Point(x,y+1);
                        pointList.add(point);
                        canVisited[x][y+1]=false;
                        waitTime();
                        DFSWay(x,y+1);
                    }
                }
                if (x-1>=0){
                    //向左
                    if (canVisited[x-1][y]){
                        Point point = new Point(x-1,y);
                        pointList.add(point);
                        canVisited[x-1][y]=false;
                        waitTime();
                        DFSWay(x-1,y);
                    }
                }
                if (y-1>=0){
                    //向上
                    if (canVisited[x][y-1]){
                        Point point = new Point(x,y-1);
                        pointList.add(point);
                        canVisited[x][y-1]=false;
                        waitTime();
                        DFSWay(x,y-1);
                    }
                }
            }else {
                int m = pointList.get(pointList.size()-1).x;
                int n = pointList.get(pointList.size()-1).y;
                pointList.remove(pointList.size()-1);
                waitTime();
                DFSWay(m,n);
            }
        }//else
    }

在建立迷宫的时候可以用DFS，也可以用BFS，下面代码采用BFS建立迷宫。

    private void BFSBuildMaze(int x,int y) {
            String a = x+","+y;
            list.add(a);
            while (list.size()>0){
                int index = (int) (Math.random() * 1000) % list.size();
                a = list.get(index);
                list.remove(index);
                x = Integer.parseInt(a.split(",")[0]);
                y = Integer.parseInt(a.split(",")[1]);
                if (!judgeNextWall(x,y)){
                    continue;
                }
                //向左
                if (x-2>=0){
                    if (canVisited[x-2][y]){
                        map[x-1][y]=false;
                        canVisited[x-2][y]=false;
                        a = x-2+","+y;
                        list.add(a);
                    }
                }
                //向右
                if (x+2<=40){
                    if (canVisited[x+2][y]){
                        map[x+1][y]=false;
                        canVisited[x+2][y]=false;
                        a = x+2+","+y;
                        list.add(a);                    
                        }
                }
                //向上
                if (y-2>=0){
                    if (canVisited[x][y-2]){
                        map[x][y-1]=false;
                        canVisited[x][y-2]=false;
                        a = x+","+(y-2);
                        list.add(a);
                    }
                }
                //向下
                if (y+2<=40){
                    if (canVisited[x][y+2]){
                        map[x][y+1]=false;
                        canVisited[x][y+2]=false;
                        a = x+","+(y+2);
                        list.add(a);                   
                        }
                }
                waitTime();
            }
    }

完整代码在git里，建立迷宫时有BFS和DFS两种：https://github.com/q1455759954/maze