21 Recursion and Backtracking

3/5/09
Intermediate / Advanced
Programming
Recursion and Backtracking
Lynn Robert Carter

2009-03-03
© Copyright 2009, Lynn Robert Carter
Agenda
 N Queens
+ Finding solutions
+ Backtracking
+ The N Queens solution
Intermediate/Advanced Programming 2
1
3/5/09
The N Queens Puzzle

+ Consider a board, like a chess board, but
one where you can specify the board size
+ How many chess queens can be placed
on this “board” so that no queen can “take”
another?
+ How many different placements of queens
can be made for a given sized board?
A board of size 5
2
3/5/09
What does “take” mean?

+ In chess a piece “takes” another piece
when it can move to the same square as
the piece it is going to take
+ The various pieces on a chess board
move in very different ways
+ Some pieces, such are rooks (castles) can
move all the way across the board, but
only up, down, left, or right
How does a Queen move?
♕!
3
3/5/09
The moves of a Queen
♕!
Safe places for a second Queen
♕! ♕!
♕! ♕!
♕!
♕! ♕!
♕! ♕!
4
3/5/09
Agenda
 N Queens
 Finding solutions
+ Backtracking
Finding solutions
+ Start in the first row, we
have a choice of five
possible moves
+ Any of these five choices
could lead to a solution
+ To move forward, we
have to choose one and
then see if that can lead
to a solution
5
3/5/09
The first move

+ To be systematic, pick the
first one; place a queen in
♕!
the first square
+ We know than no other
queen can be in that row
+ So start with the second
row and see which
squares are “safe”
Possible safe places

+ The first column is not
safe
♕!
+ The second square in the
second row is not safe
+ All of the others in the row
are safe
+ Let’s use the first one
6
3/5/09
Examine row three

+ Which of the squares in
row three are “safe”?
♕!
♕!
Examine row three

+ The only “safe” square in
this situation is the right
♕!
most square ♕!
+ So place a queen there
7
3/5/09
Examine row four

+ Where are the safe
squares in row four?
♕!
♕!
♕!
Examine row four

+ There is just one possible
square for the fourth row
♕!
+ Once again, place the ♕!
next queen there!
♕!
8
3/5/09
Examine the last row

+ Once again, there is only
one choice
♕!
♕!
♕!
♕!
A solution
+ Using this process, we
have found a solution
♕!
+ How many more solutions ♕!
are possible?
♕!
♕!
♕!
9
3/5/09
Agenda
 N Queens
 Finding solutions
 Backtracking
4 Queens
+ Consider the 4 Queens case
+ There are four possible first
moves
10
3/5/09
4 Queens row 2 choice

+ Start with a Queen in the
first row and first column
♕!
+ There are just two possible
choices for the second row
+ Let’s pick the first one
4 Queens row 2
+ Given this sized board and
these two queens, where
♕!
can a queen go for row 3? ♕!
11
3/5/09
4 Queens row 3
+ There is no “safe” move in
this situation, so be have to
♕!
back up and try a different ♕!
choice
+ This “backing up” is known
as “backtracking”
+ So, let’s back up to the most
recent point where we had a
choice, the choice in row 2
Back up to row two

+ We know that the first of
these two choices does not
♕!
lead to a solution
+ Let’s try the second of the
two choices
12
3/5/09
A second try at row three

+ With queens positioned as
shown here, where are the
♕!
possible “safe” moves in row ♕!
three?
Possible row three moves

+ With queens positioned as
shown here, there is just
♕!
one possible “safe” move, ♕!
so let’s take it
13
3/5/09
Possible row four moves

+ Where are the “safe” moves
in row four?
♕!
♕!
♕!
Another failure
+ There are no safe moves
here, so… we have to back
♕!
track again ♕!
♕!
14
3/5/09
Once again at row two

+ Now we know that neither of
the two choices for row 2
♕!
will lead us to a solution
+ Therefore, we must back up
to row 1 and try a different
choice there
Backup all the way to row 1

+ We now know that it is not
possible for 4 Queens to
have a solution with a queen
in the first row and first
column
+ Let’s try the queen in the
first row and second column
15
3/5/09

+ With a queen in this position
in the first row, there is only
♕!
one choice for row 2
+ So, let’s make that move

+ Queens in these positions
for the first two rows means
♕!
that there is again just one ♕!
choice for row three
+ So, let’s make that move
16
3/5/09

+ Queens in these positions
for the first three rows
♕!
means once again just one ♕!
choice is possible
+ So, let’s make that move ♕!
4 Queens solution
+ A queen in the first row and
second column leads to a
♕!
solution ♕!
+ How many more solutions
are possible? ♕!
♕!
17
3/5/09
Number of possible solutions

+ We know about two of the
choices in the first row
+ What is your intuition about
the other two positions?
A tree of possible solutions
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕ 12 more
not shown
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕ 60 more
♕ ♕ ♕ ♕
not shown
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕ 252 more
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕ not shown
18
3/5/09
A solution strategy
+ Build a tree of all possible valid queen
placements
+ Traverse the whole tree
+ Whenever there is a board where the
number of queens is equal the number of
rows in the board, add that board to a
collection of solutions
Possible valid placements?

+ Assume you are given a valid board and a
row number where you are to try to place
as many queens as possible
+ How can you do this?
19
3/5/09
Possible valid placements

+ Perform a loop that iterates once for each
possible placement in the new row using
the index col
+ Make a temporary copy of the board
+ Try to place the queen in the columns
specified by col
+ If that placement is valid, use it to try to place
queens in the rest of the rows (recursively)
Possible placement example
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕
♕ ♕ ♕ ♕
20
3/5/09
addQueen
/**
* Method to add a Queen to the board
* @param b The Board
* @param rowNum The starting row number to try to add the queen
*
* @return The board after placing the Queen, if possible else null
*/
public Board addQueen(Board b, int rowNum) {
// base case: number of Queens on the board is equal to the board size
if(b.numQueens() == b.getSize())
return b;
for(int x =0; x < b.getSize(); x++){

Board tempBoard = new Board(b);
// try to place the queen in the board at column x within row, rowNum
if(tempBoard.place(new Board.Position(rowNum, x))){
// If it was added successfully
// recursively try adding a queen into the next row
Board nextBoard = addQueen(tempBoard, rowNum+1);
// If it comes back null, no solution is possible

if(nextBoard != null)
// The board is not null, so this is a solution
return nextBoard;
}
}
return null;
}
getAllSolutions
/**
* Method to get all possible solutions to the Queens problem
*
* @param b The board to place the Queens at
* @param c All possible boards
* @param rowNum The initial row number to start placing queens
*/
public void getAllSolutions(Board b, Collection<Board> c, int rowNum){
if(rowNum < b.getSize()){

for(int x =0; x< b.getSize(); x++){
Board tempBoard = new Board(b);
if(tempBoard.place(new Board.Position(rowNum, x))){

// a queen is placed at that row
// recursively call the method on the next row
getAllSolutions(tempBoard, c, rowNum+1);
}
}
// getting here means that we have run past the end of the row
// so we return without adding any more boards to the collection
return;
}
// add the solved board to the Collection of boards
// this only happens when rowNum >= b.getSize()
c.add(b);
}
21
3/5/09
The Class Design of NQueens

+ The program consists of
+ A class that defines the board (Board)
+ A class that solve the problem (NQueens)
+ A class that implements a Swing GUI window
(NQueensSwing)
+ A mainline class for the Swing version of the
puzzle solver (NQueensGUI)
+ A mainline class for a text version (Driver)
The NQueen Board-1

public class Board {
protected enum BoardState implements Cloneable {
UNTHREATENED, THREATENED, QUEEN
};
protected BoardState[][] board;
private int n;
private int numQueens;
public static class Position {

int x = 0, y = 0;
public Position(int i, int j) {

x = i;
y = j;
}
public boolean equals(Position p) {

return x == p.x && y == p.y;
}
}
public int getSize(){

return this.n;
}
22
3/5/09
The NQueen Board-2

/**
* Constructs an empty board sizeXsize
*
* Complains if you attempt to construct a negative board Boards of size 0
* are allowed
*/
public Board(int size) {
if (size < 0) {
System.out.println("Negative boards are not allowed.");
return;
}
n = size;
numQueens = 0;
board = new BoardState[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
board[i][j] = BoardState.UNTHREATENED;
}
public Board(Board b) {
board = new BoardState[b.n][b.n];
for (int i = 0; i < b.n; i++)

for (int j = 0; j < b.n; j++)
board[i][j]=b.board[i][j];
n = b.n;
numQueens = b.numQueens;
}
isThreatened and more

/**
* Determines if a position can be reached in one or zero moves by any of
* the queens currently on the board
*
* @param p
* the position to determine the state of
* @return true if Position p is being threatened
*/
public boolean isThreatened(Position p) {
return board[p.x][p.y] != BoardState.UNTHREATENED;
}
/**
* accessor for the number of queens currently placed on the board
*/
public int numQueens() {
return numQueens;
}
/**
* returns true if the maximum number of queens have been placed.
*/
public boolean done() {
if (n < 1 || n == 2 || n == 3)
return (numQueens == 0);
return (numQueens == n);
}
23
3/5/09
place
/**
* Places a queen on the board at Position P if that is an empty
* unthreatened place
*
* @param p
* the position to place the queen in
*
* @return true if placement is sucsessful
*/
public boolean place(Position p) {
if (board[p.x][p.y] != BoardState.UNTHREATENED)
return false;
// mark the row and col as threatened

for (int i = 0; i < n; i++) {
board[p.x][i] = BoardState.THREATENED;
board[i][p.y] = BoardState.THREATENED;
}
// mark the diagonals as threatened

for (int x = p.x, y = p.y; x < n && y < n; x++, y++) board[x][y] = BoardState.THREATENED;
for (int x = p.x, y = p.y; x >= 0 && y >= 0; x--, y--) board[x][y] = BoardState.THREATENED;
for (int x = p.x, y = p.y; x >= 0 && y < n; x--, y++) board[x][y] = BoardState.THREATENED;
for (int x = p.x, y = p.y; x < n && y >= 0; x++, y--) board[x][y] = BoardState.THREATENED;
board[p.x][p.y] = BoardState.QUEEN;
numQueens++;
return true;
}
Agenda
 N Queens
 Finding solutions
 Backtracking
 The N Queens solution
24
3/5/09
A sample solution
+ Download the NQueens archive from the
blackboard and get it to work
+ A solution written by Hatem Alismail
+ Study the solution and be able to answer
some questions about this code
Intermediate / Advanced
Programming
Lynn Robert Carter

2009-03-03
© Copyright 2009, Lynn Robert Carter
25

21 Recursion and Backtracking

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

21 Recursion and Backtracking

Uploaded by

Copyright:

Available Formats

3/5/09

Lynn Robert Carter

© Copyright 2009, Lynn Robert Carter

The N Queens Puzzle

What does “take” mean?

How does a Queen move?

The moves of a Queen

Safe places for a second Queen

The first move

Possible safe places

Examine row three

Examine row three

Examine row four

Examine row four

Examine the last row

4 Queens row 2 choice

Back up to row two

A second try at row three

Possible row three moves

Possible row four moves

Once again at row two

Backup all the way to row 1

4 Queens row 2 choice

4 Queens row 3 choice

4 Queens row 4 choice

Number of possible solutions

A tree of possible solutions

Possible valid placements?

Possible valid placements

Possible placement example

for(int x =0; x < b.getSize(); x++){

// If it comes back null, no solution is possible

if(rowNum < b.getSize()){

if(tempBoard.place(new Board.Position(rowNum, x))){

The Class Design of NQueens

The NQueen Board-1

protected BoardState[][] board;

private int numQueens;

public static class Position {

public Position(int i, int j) {

public boolean equals(Position p) {

public int getSize(){

The NQueen Board-2

for (int i = 0; i < b.n; i++)

isThreatened and more

// mark the row and col as threatened

// mark the diagonals as threatened

Lynn Robert Carter

© Copyright 2009, Lynn Robert Carter

You might also like