Backtracking

Depth-FirstSearch
N-QueensProblem
HamiltonianCircuits
 Backtracking

Backtracking is closely related to the brute-force problem-solving method in

which the solution space is scanned, but with the additional condition that only the
possible candidate solutions are considered.
What is meant by possible solutions and how these are differentiated from the
impossible ones are issues specific to the problem being solved.

functionbacktrack(currentdepth)
ifsolutionisvalid
return/printthesolution
else
foreachelementfromA[]sourcearray
letX[currentdepth]element
ifpossiblecandidate(currentdepth+1)
backtrack(currentdepth+1)
endif
endfor
endif
endfunction

http://www.devarticles.com/c/a/Development-Cycles/The-Backtracking-Algorithm-Technique/
 Depth-First Tree Search

procedure depth_first_tree_search(v:node)
u : node;
begin
for each child u of v loop 1

depth_first_tree_search(u);
end loop; 2
11
end depth_first_tree_search;
3 10 12
We will use the convention of choosing nodes in
13
a left-to-right order (or alphabetical if labeled).
4
14 15 18
5 9
16 17
6
7 8
 Depth-First Search

Depth-First traversal is a type of backtracking in a graph. If we use an alpha-numeric

order for node traversal we can define a unique ordering of the nodes encountered in a
connected graph.

A AB FC Starting at node A we can traverse every

C AC FD other node in a depth-first order, making
B AD FH sure that we do not enter any node more
D AE F I than once.
E
F BA GB
BG GE
ABGEHDFCI
G CA GH
H I CF HD
DA HE We move forward from A to C and then
DF HF we have to backtrack to F and move
DH HG forward to I.
Edge list representation EA H I
EG I F
EH IH
 Backtracking Technique

Backtracking is used to solve problems in which a feasible solution is needed rather

than an optimal one, such as the solution to a maze or an arrangement of squares in
the 15-puzzle. Backtracking problems are typically a sequence of items (or objects)
chosen from a set of alternatives that satisfy some criterion.

6
10
14
15
 Backtracking Implementation

Backtracking is a modified depth-first search of the solution-space tree. In the case of

the maze the start location is the root of a tree, that branches at each point in the maze
where there is a choice of direction.
 N-Queens Problem
The problem of placing N queens on an NxN chessboard in such a way that no two
of them are "attacking" each other, is a classic problem used to demonstrate the
backtracking method.
A simple brute-force method would be to try placing the first queens on the first
square, followed by the second queen on the first available square, scanning the
chessboard in a row-column manner.

A more efficient backtracking approach is

to note that each queen must be in its own
column and row. This reduces the search
from (N2)! to N!.
 Sample: N Queens Backtracking Algorithm
by Antal

#include <stdio.h> int possible(int k)

#include <math.h> {
#include <conio.h> for (int i=1;i<k;i++)
if (x[i]==x[k] || abs(x[i]-x[k])==k-i)
int n, x[30]; return 0;
return 1;
int solution(int k) }
{
return k==n;
} void back(int k)
{
void print(int k) if (solution(k))
{ print(k);
for (int i=1;i<k+1;i++) else
printf("%d ",x[i]); for (x[k+1]=1; x[k+1]<=n; x[k+1]++)
printf("\n"); if (possible(k+1))
back(k+1);
}
}

void main()
Can you see how this code {
checks for "attacking" queens? char ch;
printf("Enter the size of NxN chessboard: ");
scanf("%d",&n);
printf("\nThe solution: ");
back(0);
}
 Hamiltonian Circuits Problem
A Hamiltonian circuit or tour of a graph is a path that starts at a given vertex, visits
each vertex in the graph exactly once, and ends at the starting vertex. Some graphs do
not contain Hamiltonian circuits.

v1 v2 v3 v1 v2 v3

v4 v5 v6 v4 v5 v6

A state space tree for this problem is as follows. Put the starting vertex at level 0 in the
tree, call this the zero'th vertex on the path. At level 1, consider each vertex other than
the starting vertex as the first vertex after the starting one. At level 2, consider each of
these vertices as the second vertex, and so on. You may now backtrack in this state
space tree.
 Backtracking in a State Space Tree

function ok(i)return boolean

j:index isok:boolean
begin
if i=n-1 and not W(v(n-1),v(0)) then
isok:=false
elsif i>0 and not W(v(n-1),v(i)) then
isok:=false
else
isok:=true; procedure hamiltonian(i:index)
j:=1; j : index;
while j<i and isok loop begin
if v(i)=v(j) then if ok(i) then
isok:=false; if i=n-1 then
j:=j+1; display(v(0..n-1))
end loop; else
end if; for j in 2..n loop
end ok;
v(i+1):=j;
1. The ith vertex on the path must be
adjacent to the (i-1)st vertex on the path. hamiltonian(i+1);
end loop;
2. The (n-1)st vertex must be adjacent to the end if;
0'th vertex.
end if;
3. The ith vertex cannot be one of the i-1 end hamiltonian;
vertices.
 Sample Problem

v1 v2 v3 v4 1
state space tree
2 5
v5 v6 v7 v8

5 7 2 6
graph

6 7 3

3 4 8 :
:
3 8 4

:
:
 Game Trees

The state-space tree showing all legal moves of both players starting from some valid
game state is called the game tree. We can define a function that estimates the value of
any game state relative to one of the players. For example, a large positive value can
mean that this is a good move for Player 1, while a large negative value would represent
a good move for Player 2. The computer plays the game by expanding the game tree to
some arbitrary depth and then bringing back values to the current game state node.

Ply 0
current node

Ply 1

-3 +2 +1 +3 -1 -3 -2 +1
 Mini-Max
a definition

A program starts with the current game state and generates all legal moves...all legal
responses to these moves...and so on until a fixed depth is reached.

At each leaf node, an evaluation function is applied which assigns a numerical score
to that board position. These scores are then ``backed up'' by a process called mini-
maxing, which is simply the assumption that each side will choose the line of play
most favorable to it at all times.

If positive scores favor Player 1, then Player 1 picks the move of maximum score
and Player 2 picks the move of minimum score.
 Minimax Game Tree

We will assume that a large positive value is good for the Player 1. To determine Player 1's
next move, we will search the possible moves for both players assuming that each player
will make the best possible move. Ply 1 is Player 2's move so we will want to return the
minimum value from Ply 2 into each Ply 1 node.
Ply 0 is the Player 1's move so we choose the maximum of the Ply 1 values. So the best
move for Player 1 results in at least a +1 return value...

MAX +1 Ply 0

MIN -3 +1 -3 -2 Ply 1

-3 +2 +1 +3 -1 -3 -2 +1
 Alpha-Beta Pruning Rule

If A is an ancestor of X, where A is a
max node and X is a min node, then
whenever Beta(X) < Alpha(A), we
know that if f(X) is good enough to
-1 max
be propagated all the way to B, then
it will lose to one of As alternative
moves.
-1 -3 -4 min
So in either case, f(X) will have no
influence in determining the next
move, so we can stop evaluating its
children.
max -1 +2 -3 -4
Similarly, if Y is a max node and a
descendant of B, then we can prune
Y whenever Alpha(Y) > Beta(B).
-1 -2 -3 +2 -1 -3 -4 -3 +3 +4 -4 -5 +4 +5
 Summary

Backtracking is...
an efficient means of implementing brute-force search
inherently depth-first
to be considered when any solution will do

N-Queens Problem

Hamiltonian Circuits

Game Trees

MiniMax and Alpha-Beta Pruning