Java DFS迷宫解算器在正确时返回false

我目前正在做一个小迷宫解算器项目，以便更好地掌握深度优先搜索等算法。它的工作原理是将当前位置变为2，然后检查其中一个位置（上、下、左或右），如果它是0（路径），它将向前移动，直到它被1（墙）包围，然后它是一个死胡同，它将返回

然而，奇怪的是，我的迷宫解算器一直返回false，即使它找到了通往数字3（结尾）的路。所以我有两个问题，是什么导致它返回false，以及在解算器中可以更改什么，以便只有最短路径具有数字2（即，当它回溯时，它会将死端路径变成其他路径）

提前谢谢

迷宫求解器

public class DFS {
    
    private int[][] maze;
    
    public DFS(int[][] maze) {
        
        this.maze = maze;
    }
    
    // Solves given maze recursively, input starting position in maze.
    public boolean solve(int x, int y) {
        
        maze[x][y] = 2;
        
        // 3 is the cell the algorithm is supposed to find.
        if (maze[x][y] == 3) {
            return true;
        }
        
        // Looks up.
        if (x > 0 && maze[x-1][y] == 0  && solve (x-1, y) ) {
            maze[x][y] = 2;
            return true;
        }
        // Looks down
        if (x < maze.length && maze[x+1][y] == 0  && solve (x+1, y) ) {
            maze[x][y] = 2;
            return true;
        }
        // Looks right.
        if (y < maze.length && maze[x][y+1] == 0  && solve (x, y+1) ) {
            maze[x][y] = 2;
            return true;
        }
        // Looks left.
        if (y > 0 && maze[x][y-1] == 0  && solve (x, y-1) ) {
            maze[x][y] = 2;
            return true;
        }
        
        return false;
    }
    
}

打印时溶液的图像。

---

快速看一眼就知道你做错了：

        maze[x][y] = 2;
        
        // 3 is the cell the algorithm is supposed to find.
        if (maze[x][y] == 3) { // <-- It will never be 3
            return true;
        }

---

工作解决方案：

它正确回溯并恢复到原始状态，但不是在到达末尾时才结束，而是在数字3（结尾）正上方的下一个最后一个单元格时，它只是一直回溯到末尾并返回false。@很抱歉，问题是，在if检查中，我们只访问值为0的邻居。我们还需要访问值为3的邻居：）我编辑了代码，还添加了一个工作示例。您好，我再次看到类似的迷宫解算器，但它们被称为BFS而不是DFS，我感到困惑。我的迷宫解算器不是在使用DFS吗？如果不是，为什么？再次非常感谢你！：）@编码是的，您的迷宫解算器使用DFS。此外，我不认为BFS是解决此类问题的好方法，除非你在寻找最短路径。

        maze[x][y] = 2;
        
        // 3 is the cell the algorithm is supposed to find.
        if (maze[x][y] == 3) { // <-- It will never be 3
            return true;
        }

    public boolean solve(int x, int y) {
        // 3 is the cell the algorithm is supposed to find.
        if (maze[x][y] == 3) {
            maze[x][y] = 2;
            return true;
        }

        int orig = maze[x][y];
        maze[x][y] = 2;
        
        // Looks up.
        if (x > 0 && (maze[x-1][y] == 0 || maze[x-1][y] == 3)  && solve (x-1, y) ) {
            //maze[x][y] = 2;
            return true;
        }
        // Looks down
        if (x < maze.length && (maze[x+1][y] == 0 || maze[x+1][y] == 3)  && solve (x+1, y) ) {
            //maze[x][y] = 2;
            return true;
        }
        // Looks right.
        if (y < maze.length && (maze[x][y+1] == 0 || maze[x][y+1] == 3)  && solve (x, y+1) ) {
            //maze[x][y] = 2;
            return true;
        }
        // Looks left.
        if (y > 0 && (maze[x][y-1] == 0 || maze[x][y-1] == 3)  && solve (x, y-1) ) {
            //maze[x][y] = 2;
            return true;
        }

        maze[x][y] = orig;
        return false;
    }