CSE 143
Lecture 13
Recursive Backtracking
slides created by Ethan Apter
http://www.cs.washington.edu/143/
Definitions
• recursive backtracking: backtracking using recursion
• backtracking: a brute-force technique for finding
solutions. This technique is characterized by the the
ability to undo (“backtrack”) when a potential
solution is found to be invalid.
• brute-force: not very smart, but very powerful
– more specifically: not very efficient, but will find a valid
solution (if a valid solution exists)
• Even though backtracking is a brute-force technique, it
is actually a relatively efficient brute-force technique
– it’s still slow, but it’s better than some approaches 2
Wait, what?
• Common question: what’s the difference between
“recursion” and “recursive backtracking”?
• recursion: any method that calls itself (recurses) to
solve a problem
• recursive backtracking: a specific technique
(backtracking) that is expressed through recursion
– backtracking algorithms are easily expressed with
recursion
all all recursive
recursive backtrackin
problems g problems
3
Basic Idea
• We want to try every possibility to see if it’s a solution
– unless we already know it’s invalid
• We can view this as a sequence of choices. The first
choice might look something like this:
choice #1
option option
#1 option #3
#2
• What happens if we select one of the options?
4
Basic Idea
• Suppose we choose option #3:
choice #1
option option
#1 option #3
#2
choice #2
option option
#1 option #3
#2
• We are presented with another choice (that is based on
the option we chose) 5
Basic Idea
• And this sequence of choices continues until:
– you decide you’ve made a bad choice somewhere along
the sequence and want to backtrack
– you decide you’ve arrived at a perfectly valid solution
• But this process gets pretty hard to draw, because it
fans out so much
– so you’ll have to use your imagination
• This is also why brute-force techniques are slow
– exploring every possibility takes time because there are
so many possibilities
6
8 Queens
• 8 Queens is a classic backtracking problem
• 8 Queens: place 8 queens on an 8x8 chessboard so
that no queen threatens another
– queens can move in a straight line horizontally, vertically,
or diagonally any number of spaces
possible threatened! safe!
7
moves
8 Queens
• One possible approach:
– on an 8x8 chessboard, there are 64 locations
– each of these locations is a potential location to place the
first queen (this is a choice!)
– after we place the first queen, there are 63 remaining
locations to place the second queen
• clearly, some of these won’t work, because the second queen
will threaten the first queen.
– after we place the second queen, there are 62 remaining
locations to place the third queen
– and so on
• So, there are 178,462,987,637,760 possibilities!
– 178,462,987,637,760 = 64*63*62*61*60*59*58*57
8
8 Queens
• That’s a lot of choices!
• Remember that we’re using a brute-force technique, so
we have to explore all possible choices
– now you can really see why brute-force techniques are
slow!
• However, if we can refine our approach to make fewer
choices, we can go faster
– we want to be clever about our choices and make as few
choices as possible
• Fortunately we can do a lot better
9
8 Queens
• Key observation:
– all valid solutions to 8 Queens will have exactly 1 queen
in each row and exactly 1 queen in each column
(otherwise the queens must threaten each other)
• There are exactly 8 queens, 8 rows, and 8 columns
• So rather than exploring 1-queen-per-board-location,
we can explore 1-queen-per-row or 1-queen-per-
column
– it doesn’t matter which
• We’ll explore 1-queen-per-column
10
8 Queens
• When exploring column-by-column, we have to decide
which row to place the queen for a particular column
• There are 8 columns and 8 rows
– so we’ve reduced our possible choices to 88 = 16,777,216
• So our first decision looks something like this:
for column #1, in which row
should the queen be placed?
1 2 3 4 5 6 7 8
11
8 Queens
• If we choose to place the queen in row #5, our decision
tree will look like this:
for column #1, in which row
should the queen be placed?
1 2 3 4 5 6 7 8
for column #2, in which row
should the queen be placed?
1 2 3 4 5 6 7 8
• Keep in mind that our second choice (column #2) is
affected by our first choice (column #1)
12
8 Queens
• So, why are we using backtracking?
– because backtracking allows us to undo previous choices
if they turn out to be mistakes
• Notice that as we choose which row to place each
queen, we don’t actually know if our choices will lead
to a solution
– we might be wrong!
• If we are wrong, we want to undo the minimum number
of choices necessary to get back on the right track
– this also saves as much previous work as possible
13
8 Queens
• It’s clear that we could explore the possible choices for
the first column with a loop:
for (int row = 1; row <= 8; row++) // explore column 1
• So we could solve the whole problem with nested loops
somewhat like this:
for (int row = 1; row <= 8; row++) // column 1
for (int row = 1; row <= 8; row++) // column 2
for (int row = 1; row <= 8; row++) // column 3
...
for (int row = 1; row <= 8; row++) // column 8
• But we can write this more elegantly with recursion 14
8 Queens
• Recursive backtracking problems have somewhat of a
general form
• This form is easier to see (and the code is easier to
understand) if we remove some of the low-level details
from our recursive backtracking code
• To do this, we’ll be using some code Stuart Reges
wrote. Stuart’s code is based off code written by one
of his former colleagues named Steve Fisher
• We’re going to use this code to solve N Queens
– just like 8 queens, but now we can have N queens on an
NxN board (where N is any positive number)
15
N Queens
• What low-level methods do we need for N Queens?
– We need a constructor that takes a size (to specify N):
public Board(int size)
– We need to know if it’s safe to place a queen at a location
public boolean safe(int row, int col)
– We need to be able to place a queen on the board
public void place(int row, int col)
– We need to be able to remove a queen from the board,
because we might make mistakes and need to backtrack
public void remove(int row, int col)
– And we need some general information about the board
public void print()
public int size()
16
N Queens
• Assume we have all the previous code
• With that taken care of, we just have to find a solution!
– easy, right?
• Let’s write a method called solve to do this:
public static void solve(Board b) {
...
}
• Unfortunately, solve doesn’t have enough parameters
for us to do our recursion
– so let’s make a private helper method
17
N Queens
• Our private helper method:
private static boolean explore(...) {
...
}
• What parameters does explore need?
– it needs a Board to place queens on
– it needs a column to explore
• this is a little tricky to see, but this will let each method
invocation work on a different column
• Updated helper method:
private static boolean explore(Board b, int col) {
...
}
18
N Queens
• Well, now what?
• We don’t want to waste our time exploring dead ends
– so, if someone wants us to explore column #4, we should
require that columns #1, #2, and #3 all have queens and
that these three queens don’t threaten each other
– we’ll make this a precondition (it’s a private method, after
all)
• So, now our helper method has a precondition:
// pre : queens have been safely placed in previous
// columns
19
N Queens
• Time to write our method
• We know it’s going to be recursive, so we need at least:
– a base case
– a recursive case
• Let’s think about the base case first
• What column would be nice to get to? When are we
done?
– For 8 Queens, column 9 (queens 1 to 8 placed safely)
• column 8 is almost correct, but remember that if we’re asked
to explore column 8, the 8th queen hasn’t yet been placed
– For N Queens, column N+1 (queens 1 to N placed safely) 20
N Queens
• This is our base case!
• Let’s update our helper code to include it:
private static boolean explore(Board b, int col) {
if (col > b.size()) {
return true;
} else {
...
}
}
• Well, that was easy
• What about our recursive case?
21
N Queens
• For our recursive case, suppose we’ve already placed
queens in previous columns
• We want to try placing a queen in all possible rows for
the current column
• We can try all possible rows using a simple for loop:
for (int row = 1; row <= board.size(); row++) {
...
}
• This is the same for loop from before!
– remember, even though we’re using recursion, we still want
to use loops when appropriate 22
N Queens
• When do we want to try placing a queen at a row for the
specified column?
– only when it is safe to do so!
– otherwise this location is already threatened and won’t lead
us to a solution
• We can update our code:
for (int row = 1; row <= board.size(); row++) {
if (b.safe(row, col)) {
...
}
}
• We’ve picked our location and determined that it’s safe
– now what?
23
N Queens
• We need to place a queen at this spot and decide if we
can reach a solution from here
– if only we had a method that would explore a Board from
the next column and decide if there’s a solution...
– oh wait! That’s what we’re writing
• We can update our code to place a queen and recurse:
for (int row = 1; row <= board.size(); row++) {
if (b.safe(row, col)) {
You might be
b.place(row, col);
tempted to write
explore(b, col + 1);
col++ here instead,
...
but that won’t work.
} Why not?
}
24
N Queens
• Also, we don’t want to call explore quite like that
– explore returns a boolean, telling us whether or not we
succeeded in finding a solution (true if found, false
otherwise)
• What should we do if explore returns true?
– stop exploring and return true (a solution has been found)
• What should we do if explore returns false?
– well, the queens we’ve placed so far don’t lead to a
solution
– so, we should remove the queen we placed most recently
and try putting it somewhere else
25
N Queens
• Updated code:
for (int row = 1; row <= board.size(); row++) {
if (b.safe(row, col)) {
This pattern
b.place(row, col);
(make a
if (explore(b, col + 1)) { choice,
return true; recurse, undo
} the choice) is
b.remove(row, col); really common
} in recursive
} backtracking
• We’re almost done. What should we do if we’ve tried
placing a queen at every row for this column, and no
location leads to a solution?
– No solution exists, so we should return false
26
N Queens
• And we’re done! Here’s the final code for explore:
private static boolean explore(Board b, int col) {
if (col > b.size()) {
return true;
} else {
for (int row = 1; row <= board.size(); row++) {
if (b.safe(row, col)) {
b.place(row, col);
if (explore(b, col + 1)) {
return true;
}
b.remove(row, col);
}
}
return false;
}
}
27
N Queens
• Well, actually we still need to write solve
– don’t worry, it’s easy!
• We’ll have solve print out the solution if explore finds
one. Otherwise, we’ll have it tell us there’s no solution
• Code for solve:
public static void solve(Board b) {
if (explore(b, 1)) {
System.out.println(“One solution is as follows:”);
b.print();
} else {
System.out.println(“No solution”);
}
}
28
N Queens
• We’re really done and everything works
– try running the code yourself!
– I think it’s pretty cool that such succinct code can do so
much
• There’s also an animated version of the code
– it shows the backtracking process in great detail
– if you missed lecture (or if you just want to see the
animation again), download queens.zip from the class
website and run Queens2.java
29
