0

I am trying to write a program in C that tracks the entire search process of a recursive backtracking algorithm of a maze solver. Thus, I'll be printing out every step taken. The maze is a simple one with '#' representing walls, '.' representing empty cells and '@' representing the initial starting point. Given a starting point, we have to reach any of the edges of the maze to complete it. My search algorithm begins with trying to search for a path north, then east, then south then west. (I used this for reference: http://www.cs.bu.edu/teaching/alg/maze/)

Example of an input of a given maze:

#######
###.###
###.###
...@..#
###.###
###.###
#######

What my code is trying to do / output:

//step 1
#######
###.###
###.###
...+..#
###.###
###.###
#######

//step 2
#######
###.###
###+###
...+..#
###.###
###.###
#######

//Step 3
#######
###+###
###+###
...+..#
###.###
###.###
#######

//Step 4
#######
###X###
###+###
...+..#
###.###
###.###
#######

//step 5
#######
###X###
###X###
...+..#
###.###
###.###
#######

//Step 6
#######
###X###
###X###
...++.#
###.###
###.###
#######
.
. subsequent steps leading to final output
.
.
#######
###X###
###X###
++++XX#
###X###
###X###
#######

Here is a sample of the relevant functions from my code trying to execute this:

bool is_goal(long row, long col, long m, long n)
{
    if (row == 0 || col == 0 || row == m - 1 || col == n - 1) {
        return true;
    }
    return false;
}
 
bool is_wall(char **maze, long row, long col)
{
   if (maze[row][col] == WALL) {
       return true;
   }
   return false;
}
 
bool find_path(char **maze, char **maze_cpy, long row, long col, long m, long n, long     step)
{
    print_maze(maze_cpy, m, step);
    step += 1;
 
    //Base cases
    if (is_goal(row, col, m, n)) {
        return true;
    }
    if (is_wall(maze, row, col)) {
        return false;
    }
    //used to indicate current cell is part of soln
    maze_cpy[row][col] = '+';
 
    //Recursive cases
    //Go up
    if (find_path(maze, maze_cpy, row - 1, col, m, n, step)) {
        return true;
    }
    //Go right
    if (find_path(maze, maze_cpy, row, col + 1, m, n, step)) {
        return true;
    }
    //Go down
    if (find_path(maze, maze_cpy, row + 1, col, m, n, step)) {
        return true;
    }
    //Go left
    if (find_path(maze, maze_cpy, row, col - 1, m, n, step)) {
        return true;
    }
    //At this point, no solution
    maze_cpy[row][col] = 'X';
    return false;
}

However, my output recursive function just stops at step 3 and I can't figure out why it does not backtrack and update the path it has taken as an unusable path (with an 'X'). Help will be greatly appreciated. (Sorry for the really long question, I tried to format it as nicely as possible).

Jenson Mutton
  • 91
  • 6
  • 1
    Have you tried to step through the code in a debugger? What does that tell you? – Some programmer dude Nov 01 '20 at 03:04
  • @Someprogrammerdude Yes. The function just stops after hitting the wall for the first time. I was wondering if I have to explicitly make the find_path function return to the previous level of recursion when false is returned. – Jenson Mutton Nov 01 '20 at 03:34

1 Answers1

0

There are more characters that find_path needs to stop (return false) for than just a WALL. In the initial case, once it hits that top wall, it will look right and sees a wall, then looks down and sees a '+', which is not a wall so it continues by starting a new search. You end up bouncing between those two squares in the maze.

find_path needs to immediately return false if the moved to is not a floor. Something is not a floor if it is a WALL, part of the solution, or not a solution. Alternatively, check for floor characters (which seem to be just the '.').

1201ProgramAlarm
  • 32,384
  • 7
  • 42
  • 56
  • Hi, I tried checking for floor character instead and the same issue still persists where the program terminates after hitting the top wall. – Jenson Mutton Nov 01 '20 at 04:32