Maze solver recording backtracked paths - c++

Question

I've gotten my maze solver program to work but it seems to be including back tracked spaces (places it went to and hit a wall so it had to turn around) in the final solution path that it outputs. Here is an example:
How can I prevent this in my current implementation below:
int dir = 4;
bool visited[Max_Maze][Max_Maze][dir];
for (row = 0; row < size; ++ row)
{
for (col = 0; col < size; ++ col)
{
for (dir = 0; dir < 4; ++ dir)
{
visited[row][col][dir]=false;
}
}
}
bool notSolved = true;
int path = 0;
row = 0;
col = 0;
rowStack.push(row);
colStack.push(col);
while (notSolved)
{
//from perspective of person looking at maze on screen
if (((row-1)>=0)&&(maze[row - 1][col] == 0)&&(visited[row][col][0]==false))
{
// if that space is not out of bounds and if you can go up
// and you have not gone in that direction yet, go up
visited[row][col][0] = true;
row--;
rowStack.push(row);
colStack.push(col);
path++;
}
else if (((col+1)<size)&&(maze[row][col + 1] == 0)&&(visited[row][col][1]==false))
{
//else if you can go right etc., go right
visited[row][col][1] = true;
col++;
rowStack.push(row);
colStack.push(col);
path++;
}
else if (((row+1)<size)&&(maze[row + 1][col] == 0)&&(visited[row][col][2]==false))
{
//else if you can go down etc., go down
visited[row][col][2] = true;
row++;
rowStack.push(row);
colStack.push(col);
path++;
}
else if (((col-1)>=0)&&(maze[row][col - 1] == 0)&&(visited[row][col][3]==false))
{
//else if you can go left etc., go left
visited[row][col][3] = true;
col--;
rowStack.push(row);
colStack.push(col);
path++;
}
else
{
//if stuck
if (path == 0)
{
cout << "No Solution Path" << endl;
notSolved = false;
}
else
{
rowStack.pop();
colStack.pop();
row = rowStack.top();
col = colStack.top();
path--;
}
}
if((maze[row][col] == 0) && (row == (size - 1) && col == (size - 1)))
{
//if we reached an exit
cout << "Solution Path:(in reverse)" << endl;
for (int i = 0; i <= path; i++)
{
cout << "row:" << rowStack.top() << " col:" << colStack.top() << endl;
rowStack.pop();
colStack.pop();
}
notSolved = false;
}
}
Simple fix or total restructuring needed?

Answer 1

As the solver goes right into that dead end, it records that it has "visited right from (R, C)", because your visited array is three dimensional. But it never records that it has "visited left from (R, C + 1)". So it thinks it's fine to move to the same position twice, so long as it doesn't make the exact same move twice (which it doesn't, as it's moving left when it backtracks, not right).
It looks like it will work fine as is if you change visited to be a 2-dimensional array and only record positions, not moves. Then every square you've visited before blocks further movement, but that's okay because if the correct solution requires going back to that square you'll eventually hit the else case enough to pop back to it, and from there three must be a never-visited square to explore.

Answer 2

Without commenting on your specific solution, you might consider redoing as a standard depth first search algorithm, which I think you will agree is somewhat more clear:
boolean dfs (State s) {
if (end_state(s)) {
return true;
}
vector<option_t> options = generate_moves(s);
for (vector<option_t>::iterator it = options.begin();
it != options.end(); it++) {
make_move(s, it);
boolean found = dfs(s);
if (found) {
cout << s << endl;
}
undo_move(s, it);
if (found) return true;
}
return false;
}
As you can see, this will work as long as you can create:
some class State that holds your current maze state
end_state function that knows when State is at a solution
generate_moves function that can find all options for current State
make_move that can apply a move against your state
undo_move that can undo a move against state
you define option_t such that it represents a move option
define operator<< for State
I can tell you that certainly the solution I give you does not have problems with printing backtracked spaces (should be clear also from the code).