Question

我正在尝试实现深度优先算法来解决迷宫，但我以某种方式编写的代码似乎没有做任何事情，既不会引发错误也不会产生预期的结果，这就是＆＃34;填充＆＃34;路径带有被访问的coordenates的数组，因为当我打印路径数组时，我得到一个空数组。

public static boolean searchPath(char[][] maze, int x, int y, List<Integer> path) {

    if(maze[y][x]=='E') {
        path.add(x);
        path.add(y);
        return true;
    }
    if(maze[y][x]=='_') {

        int dx = -1;
        int dy = 0;
        if(x +dx >0 && y + dx > 0 && x + dx < maze.length && y + dx < maze[0].length && searchPath(maze,x+dx,y+dy,path)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 1;
        dy = 0;
        if (x +dx >0 && y + dx > 0 && x + dx < maze.length && y + dx < maze[0].length && searchPath(maze, x + dx, y + dy, path)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 0;
        dy = -1;
        if (x +dx >0 && y + dx > 0 && x + dx < maze.length && y + dx < maze[0].length &&  searchPath(maze, x + dx, y + dy, path)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 0;
        dy = 1;
        if (x +dx >0 && y + dx > 0 && x + dx < maze.length && y + dx < maze[0].length && searchPath(maze, x + dx, y + dy, path)) {
            path.add(x);
            path.add(y);
            return true;
        }
    }
    return false;

}

}

这里是我称之为searchPath的地方。

    public MazeReader() {

        setTitle("Maze");
        setSize(640,480);
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        DepthFirst.searchPath(Maze, 0, 1, path);
        pathIndex = path.size() - 2;

}

这是我正在处理的迷宫：

_SW_____W
_WWW_W_WW
_____W_EW

我认为问题可能在于迷宫所在的previuos阵列存储未正确导入DepthFirst类。该问题的任何解决方案？

Answer 1

首先，你永远不会检查起始符号，因此它从一开始就失败了。将其添加到行

 if(maze[y][x]=='_' || maze[y][x] == 'S') {

下一行中存在许多问题

if (x +dx >0 && y + dx > 0 && x + dx < maze.length && y + dx < maze[0].length

它应该是x + dx＆gt; = 0，因为它可以为0.你使用x来检查嵌套数组，所以它应该是x + dx＆lt;迷宫[0] .length＆amp;＆amp; y + dy＆lt; maze.length。你可以多次添加y + dx而不是y + dy。

最后，你需要一些方法来避免多次回到同一个坐标。你拥有它的方式会导致堆栈溢出，因为搜索将永远在两个坐标之间来回传递。我添加了一个名为checked的布尔数组，该数组与检查坐标时设置为true的迷宫大小相同，以避免再次返回到该点。

这一切都在一起。

 public static void main(String[] args) {
    List<Integer> l = new LinkedList<Integer>();
    char[][] maze = {{'S', '_', '_'},{'W','W','E'}};
    boolean[][] checked = new boolean[2][3];
    searchPath(maze, 0, 0, l, checked);
    System.out.println(l.toString());
}

public static boolean searchPath(char[][] maze, int x, int y, List<Integer> path, boolean checked[][]) {

    if(checked[y][x]){
        return false;
    }
    checked[y][x] = true;

    if(maze[y][x]=='E') {
        path.add(x);
        path.add(y);
        return true;
    }
    if(maze[y][x]=='_' || maze[y][x] == 'S') {

        int dx = -1;
        int dy = 0;
        if(x +dx >=0 && y + dy >= 0 && x + dx < maze[0].length && y + dy < maze.length && searchPath(maze,x+dx,y+dy,path, checked)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 1;
        dy = 0;
        if(x +dx >=0 && y + dy >= 0 && x + dx < maze[0].length && y + dy < maze.length && searchPath(maze,x+dx,y+dy,path, checked)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 0;
        dy = -1;
        if(x +dx >=0 && y + dy >= 0 && x + dx < maze[0].length && y + dy < maze.length && searchPath(maze,x+dx,y+dy,path, checked)) {
            path.add(x);
            path.add(y);
            return true;
        }

        dx = 0;
        dy = 1;
        if(x +dx >=0 && y + dy >= 0 && x + dx < maze[0].length && y + dy < maze.length && searchPath(maze,x+dx,y+dy,path, checked)) {
            path.add(x);
            path.add(y);
            return true;
        }
    }
    return false;
}

寻找迷宫错误的路径

1 个答案: