为什么我的递归方法基本情况没有返回应有的布尔值？

Question

I have written a method that solves a given text editor maze through stacks and recursion, and it solves mazes. However, my issue is that when the maze given is unsolvable as in it is literally impossible to be solved because of the walls of the maze, it's almost as if my base case is being skipped over and not returning false. Here is the code

 private boolean findPath(MazeLocation cur, MazeLocation finish) {
        int row = cur.row;
        int col = cur.col;
        mazeToSolve.setChar(row, col, 'o');
        fileWriter.println("\n"+mazeToSolve.toString());
        char strX = 'X';
        char strH = 'H';

        // First ,we need to scan the 4 directions around current location to see where to go
        MazeLocation up = new MazeLocation(row-1, col);
        MazeLocation down = new MazeLocation(row+1, col);
        MazeLocation right = new MazeLocation(row, col+1);
        MazeLocation left = new MazeLocation(row, col-1);

        // BASE CASE - WHEN WE'VE REACHED FINISH COORDINATES
        if(cur.row == finish.row && cur.col == finish.col){
            return true;
        }
        // SECOND BASE CASE - IF MAZE ISNT SOLVABLE
        if (path.isEmpty() == true){ // if the path is empty, then there is no solution.
            return false;
        }

        // Check if we can go up
        if(up.getRow() >= 0){
            if(mazeToSolve.getChar(up.getRow(), up.getCol()) == ' '){
                row = up.getRow();
                col = up.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

        // Check if we can go down
        if(down.getRow() < mazeToSolve.getRows()){
            if(mazeToSolve.getChar(down.getRow(), down.getCol()) == ' '){
                row = down.getRow();
                col = down.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

        // Check if we can go right
        if(right.getCol() < mazeToSolve.getCols()){
            if(mazeToSolve.getChar(right.getRow(), right.getCol()) == ' '){
                row = right.getRow();
                col = right.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

        // Check if we can go left
        if(left.getCol() >= 0){
            if(mazeToSolve.getChar(left.getRow(), left.getCol()) == ' '){
                row = left.getRow();
                col = left.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

         // If we cant do any of the above then we need to backtrack by popping the top of stack
         // and leaving X's until we can move up, down, left, or right again.
         MazeLocation newCur = new MazeLocation(row, col);
         path.pop(); // popping the cur where we are putting the x
         mazeToSolve.setChar(row, col, 'x'); // putting the x
         return findPath(path.top(), finish); // now we need to return to the position where the stack is NOW after the pop
    }

As you can see, there are two base cases. One returns true - the maze is solved. And the other returns false - the maze is unsolvable. The code for my isEmpty() method is as such:

public boolean isEmpty() {
        if(head == null){
            return true;
        }
        return false;
    }

It returns false by checking if the stack is empty. For example, if the maze runner runs into a wall and turns around it will leave an x in the text editor like so:

 0123456
0HHHHHHH
1ooooxxH
2HHHoHxH
3H  oHxH
4H HoHHH
5H Hoooo
6HHHHHHH

The maze starts at 6,5; and ends at 0,1. This is solvable. The x's represent a failed route, the o's represent the path from start to finish.

In this next example maze, it is impossible to finish when the code would start at 7,6.

HHHHHHH
      H
HHH H H
H   H H
H HHHHH
H H    
HHHHHHH

It would attempt to move left twice, leaving x's, then the stack would pop until there is no stack and the top of the stack is pointing towards null. But my base case code is being skipped over, it SHOULD BE testing if the stack is empty before trying to pop the empty stack, and if it is, then returning false. But it isn't. Any help please?

Answer 1

First of all, lets try to understand the problem statement first. We are trying to find a possible path from source to target using depth first approach here.

There is one major flaw in the algorithm which is around the lines

        // Check if we can go up
        if(up.getRow() >= 0){
            if(mazeToSolve.getChar(up.getRow(), up.getCol()) == ' '){
                row = up.getRow();
                col = up.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

        // Check if we can go down
        if(down.getRow() < mazeToSolve.getRows()){
            if(mazeToSolve.getChar(down.getRow(), down.getCol()) == ' '){
                row = down.getRow();
                col = down.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                return findPath(newCur, finish);
            }
        }

consider we are currently at point (2,2) and have an option to move in either of the 4 directions ie (1,2) , (3,2) , (1,3) , (2,1).

As per your logic. we move in up direction first (1,2)

There could be 2 possibilities.

1. You find a path from this point (returns true)
2. You don't find a path and want to continue search to other three options. (returns false)

Your code currently won't explore further options if the path leads to a failure due to the return statement

return findPath(newCur, finish);

This issue boils down to premature exit from the method before all operations are finished.

the following stack cleanup must be called before any return statement from the method which is currently called in only one of the scenarios

// If we cant do any of the above then we need to backtrack by popping the top of stack
// and leaving X's until we can move up, down, left, or right again.

path.pop(); // popping the cur where we are putting the x

I still did not understand the usage of explicit stack here completely. as recursion solves the similar problem which you are trying to solve using a stack.However, I would like to suggest improvements around the following lines.

// Check if we can go up
        if(up.getRow() >= 0){
            if(mazeToSolve.getChar(up.getRow(), up.getCol()) == ' '){
                row = up.getRow();
                col = up.getCol();
                MazeLocation newCur = new MazeLocation(row, col);
                path.push(newCur);
                boolean val =  findPath(newCur, finish);
                if(val){
                  path.pop();
                  return true;
                }

            }
        }