Recursive Backtracking Explanation

Thanks to Lon Ingram for this explanation of recursive backtracking.

Backtracking problems are solved one step at a time. Literally! Here's the
general algorithm:

1) Is where I am a solution?

2) No. Ok, where can I go from here? If I can go somewhere, choose a place to
go.

3) Go there.

5) Was that a solution? If yes, return true!

5) If there are remaining places to go, choose one and goto #3.

6) Out of places to go. Return false.

(*) #3 is the recursive step. At that point you are in a new place, and you
start from #1 again

Imagine that you went to the library looking for a book, but oddly didn't know
how to look one up using the alphabet or the Dewey decimal system. What would
be a good way of systematically finding the book?

Imagine that the stacks look like this:

`---> x`

[===| |===]

[===| |===]

[===| |===]

[===| |===]

Where [ and ] indicate dead ends, = indicates a shelf of books and | | indicates
a central aisle between the books. I've chosen an arbitrarily small portion of
the library to illustrate the algorithm, but you may realize that's irrelevant
later on.

So, you're at the x. How to proceed?

One way is to step into the aisle and see where you can go from here:

`[===|x|===]`

[===| |===]

[===| |===]

[===| |===]

You can go right, left or forward. So, let's try right:

`[===| |x==]`

[===| |===]

[===| |===]

[===| |===]

No luck...

Where can you go from here? Because you just came from backward, you can only
go forward. So, do that. Now, notice that I've marked where we just were with
a '#' because there are no more places to go from there. You might need to do
this in code, you might not. It depends on your algorithm. The meaning of # in
this case is just that there are no unexplored exits from that point in the
library.

`[===| |#x=]`

[===| |===]

[===| |===]

[===| |===]

No luck...

Where can you go from here? Because you just came from backward, you can only
go forward.

`[===| |##x]`

[===| |===]

[===| |===]

[===| |===]

Man. No luck here either. On top of that, you ran out of places to go, because
there's a wall in front of you. So, back up until you have another place to go:

`[===| |#x#]`

[===| |===]

[===| |===]

[===| |===]

Nope...

`[===| |x##]`

[===| |===]

[===| |===]

[===| |===]

Nope...

`[===|x|###]`

[===| |===]

[===| |===]

[===| |===]

Ah, ok, from here, you can go right, or forward. Let's go forward. What we
just did was the backtracking portion of the algorithm.

`[===| |###]`

[===|x|===]

[===| |===]

[===| |===]

From here, you can go left, right or forward. If you repeat this process, you
will examine every shelve in the library. Let's imagine that we know where the
book is:

`[===| |###]`

[===|x|===]

[=B=| |===]

[===| |===]

If you always chose the same order of directions to try (and that's usually what
you want to do), you will explore these areas before you find the book:

`[===| |###]`

[===| |###]

[=B#| |###]

[###|#|###]

At that point, you've 'solved' your book finding problem, and should return true
or the book's location or whatever it is that you are trying to determine. Now,
imagine that the book isn't in this part of the library. You will actually
examine every section of the library and eventually return to where you started
from.

`[###|x|###]`

[###|#|###]

[###|#|###]

[###|#|###]

At this point, you know that you didn't find it, so return false.

Make sense? Here's a *pseudojava* implementation:

`boolean findBook(string book, point coords)`

{

if (shelves.shelfAt(coords).contains(book))

{

return true;

}

else

{

while (shelves.hasExit())

{

// nextExit returns the coordinates of where the next exit

// leads to and marks that exit as used up

if (findBook(book, shelves.nextExit()))

{

// found it!

return true;

}

}

}

// ran out of places to go. this is a dead end.

return false;

}

So, for further consideration:

floor 1:

`[===| |===]`

[===| |===]

[===| |===]

[===| |===]

floor 2:

`[===| |===]`

[===| |===]

[===| |===]

[===| |===]

floor 3:

`[===| |===]`

[===| |===]

[===| |===]

[===| |===]

1) How would you change the algorithm above to handle moving between multiple
floors in your search?

2) How could the above algorithm be changed to find the number of possible phone
numbers in a particular area code, excepting those that start with some set of
disallowed numbers such as {555, 666, 911, 411, 211, 311}? Pro-hint: what if we
numbered all the shelves in some systematic way and then counted the number of
shelves we examined?