我现在正在做一个小的迷宫解算器项目，以便更好地掌握深度优先搜索等算法。它的工作原理是将当前位置转换为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;
    }

}

硬编码迷宫

import java.util.ArrayList;

public class TestMazeDFS {
    private static int[][] maze = {
            {1, 1, 1, 1, 1, 1, 1, 1, 1},        
            {1, 0, 0, 0, 0, 0, 0, 0, 1},
            {1, 0, 1, 0, 1, 1, 1, 1, 1},
            {1, 0, 1, 0, 0, 0, 0, 0, 1},
            {1, 1, 1, 1, 1, 0, 1, 0, 1},
            {1, 0, 0, 0, 1, 0, 1, 0, 1},
            {1, 0, 1, 1, 1, 1, 1, 0, 1},
            {1, 0, 0, 0, 0, 0, 0 ,0, 1},
            {1, 1, 1, 1, 1, 1, 1, 3, 1},
        };

    public int[][] getMaze(){

        return this.maze;
    }

    public static void main(String[] args) {

        DFS dfs = new DFS(maze);
        boolean test = dfs.solve(1, 1);
        System.out.println(test);

    }
}

打印时溶液的图像。

https://imgur.com/a/uqhp81o