在C ++递归错误中找到通过迷宫的路径

Question

I'm trying to write a function which finds a path through a maze. There is another function reads the maze from a text file. For now the function I wrote to find the path works fine when the maze is 20 rows and 20 columns but it does not work with any other variations. Here is is the code I've wrote for the function:

void find_paths(maze m, int r, int c, int rows, int cols) {
  if (r == rows - 1)
    display(m, rows, cols);
  else {
    if (r > 0 && m[r - 1][c] == space) // UP
    {
      m[r - 1][c] = path;
      find_paths(m, r - 1, c, rows, cols);
      m[r - 1][c] = space;
    }
    if (m[r + 1][c] == space) // DOWN
    {
      m[r + 1][c] = path;
      find_paths(m, r + 1, c, rows, cols);
      m[r + 1][c] = space;
    }
    if (m[r][c - 1] == space) // LEFT
    {
      m[r][c - 1] = path;
      find_paths(m, r, c - 1, rows, cols);
      m[r][c - 1] = space;
    }
    if (m[r][c + 1] == space) // RIGHT
    {
      m[r][c + 1] = path;
      find_paths(m, r, c + 1, rows, cols);
      m[r][c + 1] = space;
    }
  }
}

space is a char =' ' path is a char ='.'

And here is a screenshot for the file of the maze that the program reads.

And here is a screenshot for the program execution.

I'm new to C++ hope you can help me.

Answer 1

As mentioned in a comment by Benjamin Barrois you need a way to know that you checked out a route and if so not take it again.

I would suggest another character than the '.' (path) to distinguish dead-ends from the actual solution although even that is not exactly enough.

So I would add a variable named visited = 'x'; and use that on return.

Also, you check r > 0 in the first test (UP) but you did not check any such limit in the other if() (DOWN, LEFT, RIGHT). Although if you have the correct characters there, it will work (ie it will hit a wall first) but if that's not the case, you'll start hitting the wrong characters.

void find_paths(maze m, int r, int c, int rows, int cols) {
  if (r == rows - 1)
    display(m, rows, cols);
  else {
    if (r > 0 && m[r - 1][c] == space) // UP
    {
      m[r - 1][c] = path;
      find_paths(m, r - 1, c, rows, cols);
      m[r - 1][c] = visited;
    }
    if (r + 1 < rows && m[r + 1][c] == space) // DOWN
    {
      m[r + 1][c] = path;
      find_paths(m, r + 1, c, rows, cols);
      m[r + 1][c] = visited;
    }
    if (c > 0 && m[r][c - 1] == space) // LEFT
    {
      m[r][c - 1] = path;
      find_paths(m, r, c - 1, rows, cols);
      m[r][c - 1] = visited;
    }
    if (c + 1 < cols && m[r][c + 1] == space) // RIGHT
    {
      m[r][c + 1] = path;
      find_paths(m, r, c + 1, rows, cols);
      m[r][c + 1] = visited;
    }
  }
}

That being said, your current algorithm doesn't stop when it finds a solution since it is recursive, it will go on forever. If you want to be able to bail out, your function needs to return true (success!) or false (continue search).

Although the idea to use a recursive mechanism can be useful to find all the solutions and especially (if you were to calculate that) the length of the solution so you return only the shorter solution (which is often what a maze search is about.)

bool find_paths(maze m, int r, int c, int rows, int cols) {
  if (r == rows - 1) {
    display(m, rows, cols);
    return true;
  }
  else {
    if (r > 0 && m[r - 1][c] == space) // UP
    {
      m[r - 1][c] = path;
      if(find_paths(m, r - 1, c, rows, cols)) {
        return true;
      }
      m[r - 1][c] = visited;
    }
    if (r + 1 < rows && m[r + 1][c] == space) // DOWN
    {
      m[r + 1][c] = path;
      if(find_paths(m, r + 1, c, rows, cols) {
        return true;
      }
      m[r + 1][c] = visited;
    }
    if (c > 0 && m[r][c - 1] == space) // LEFT
    {
      m[r][c - 1] = path;
      if(find_paths(m, r, c - 1, rows, cols) {
        return true;
      }
      m[r][c - 1] = visited;
    }
    if (c + 1 < cols && m[r][c + 1] == space) // RIGHT
    {
      m[r][c + 1] = path;
      if(find_paths(m, r, c + 1, rows, cols) {
        return true;
      }
      m[r][c + 1] = visited;
    }
  }
  return false;
}

As a side note, this is not specific to C++.

Answer 2

There's not much wrong (although it could be done more efficiently). Most likely it's not working because you are missing bounds checks for columns. Since you allow the columns to obtain any value, you're probably going outside the bounds of the maze. Your other problem is that when you reach the solution, you still have all the other recursive paths being taken.

This is just a minor change from your code and should work:

bool done = false;

void find_paths(maze m, int r, int c, int rows, int cols) {
  if(done) {
      return;
  }
  if (r == rows - 1) {
    display(m, rows, cols);
    done = true;
  } else {
    if (r > 0 && m[r - 1][c] == space) // UP
    {
      m[r - 1][c] = path;
      find_paths(m, r - 1, c, rows, cols);
      m[r - 1][c] = space;
    }
    if (m[r + 1][c] == space) // DOWN
    {
      m[r + 1][c] = path;
      find_paths(m, r + 1, c, rows, cols);
      m[r + 1][c] = space;
    }
    if (c > 0 && m[r][c - 1] == space) // LEFT
    {
      m[r][c - 1] = path;
      find_paths(m, r, c - 1, rows, cols);
      m[r][c - 1] = space;
    }
    if (c < cols && m[r][c + 1] == space) // RIGHT
    {
      m[r][c + 1] = path;
      find_paths(m, r, c + 1, rows, cols);
      m[r][c + 1] = space;
    }
  }
}