基于堆栈的迷宫算法背后的逻辑

Question

I'm fairly new to C++ programming, and I'm working on a maze solving algorithm. I need to use an explicit stack to keep track of the moves of done, no recursion.

Basically I'm responsible for the "Solver" algorithm, I can check to see if a move is available or blocked and do it, or I can undo a move. The moves are left, right and forward. There is already code that takes care of drawing and updating the maze.

What I could use is just some help understanding the basic algorithm for traversing the maze. I've looked at a lot of different programs for doing it, but I just can't seem to figure it out. The maze I'm solving is generated randomly, with no loops.

Here is what I can't wrap my mind around: say I have a straight section of wall, but there's a branch coming out of the wall as well. Say I decide to go down this other branch, but eventually it leads to a dead end. I've pushed all the moves I've done onto the stack. Basically, how do I know how many moves I need to pop off the stack to know I'm back at the original junction, so I can take the other branch instead of the blocked one?

Thanks for any help!

Answer 1

Here is what I can't wrap my mind around: Say I decide to go down this other branch, but eventually it leads to a dead end. I've pushed all the moves I've done onto the stack. Basically, how do I know how many moves I need to pop off the stack to know I'm back at the original junction, so I can take the other branch instead of the blocked one?

All you need to do is always make the choices in a predefined order.

The moves are left, right and forward.

If you always make those choices in that order, you'll know what you've already done when you backtrack.

Each step you backtrack, check those moves again. If you're undoing a right choice, you'll know that you've tried left and right , but haven't yet tried forward .

Answer 2

To start off, add all possible moves from the starting position. Then, just follow this algorithm:

At every iteration, try to pop a single frame off the stack. If the stack was empty, you have tried all possible moves.

Now, look at the position you popped from the stack. This is your current position.

Add all moves from the position you popped which lead to unexplored positions to the stack. If any of them is a goal position, you're done.

The rest will take care of itself. Give it some thought, try a few cases on paper, you'll see. :)

Answer 3

You don't have many solutions: basically, exploring a maze with no loop is like doing a depth first search on the covering tree , each intersection being a node.

You can build the tree as you go, and use that information to walk through it, but this will be tedious an not very efficient .

A common method of depth first search is to push all the nodes to be checked on the stack, pull one, and push again, until you reach the goal. But you get a lot of nodes stacked up, and once you found the target node, you cannot use the stack to know which path you've followed, which means that you need to store that information elsewhere.

It is probably better to keep the stack solution and tag the nodes in your stack to indicate a branch, and which direction (ie. which subtree) of the branch have been explored (or which paths are left). If you do the exploration always in the same order , that tag can simply be a number:

• 0 for left
• 1 for front
• 2 for right
• 3 for backtrack

or better yet an enum.

When a dead end is found, just unwind the stack till you find one of these nodes, and try a new direction. If all directions have been tried, in other words if there's no direction left, unwind again.

enum Branch {
   LEFT,
   FORWARD,
   RIGHT,
   BACKTRACK
};

struct BacktrackException{
};

template <typename MazeMove>
struct StackNode {
    MazeMove move;
    Branch branch;
    StackNode(MazeMove m): move(m), branch(LEFT) {}
    MazeMove nextBranch(){
        switch(branch){
            case LEFT:
                if (move.can_left()){
                    branch = FORWARD;
                    return move.left();
                }
            case FORWARD:
                if (move.can_forward()){
                    branch = RIGHT;
                    return move.forward();
                }
            case RIGHT:
                if (move.can_right()){
                    branch = BACKTRACK;
                    return move.right();
                }
            default:
                throw BacktrackException();
        }
    }
};

The above code provide a wrapper for a possible "MazeMove" class used with the stack, which keeps track of the attempted direction. The nextBranch method returns the next possible move, or throws an exception.

The advantage is that your stack doesn't get clobbered with untried moves. You push a StackNode each time you reach a new position, and unwind it when its options have been all tested out. When you reach the maze exit, your stack contain only the needed moves.

Answer 4

Basically, how do I know how many moves I need to pop off the stack to know I'm back at the original junction, so I can take the other branch instead of the blocked one?

You don't – you always go back exactly one step. Then check all (remaining) alternatives, then go back one step further … etc. This is called backtracking .

By the way, this is identical whether you use recursion or not. Using recursion just makes the stack implicit, and the stack handling automatic.