Backtracking: General Method

BACKTRACKING
GENERAL METHOD
• Problems searching for a set of solutions or which
require an optimal solution can be solved using the
backtracking method .
• To apply the backtrack method, the solution must
be expressible as an n-tuple(x1,…,xn), where the
xi are chosen from some finite set si
• The solution vector must satisfy the criterion
function P(x1 , ….. , xn).
1
BACKTRACKING (Contd..)
• Suppose there are m n-tuples which are
possible candidates for satisfying the
function P.
• Then m= m1, m2…..mn where mi is size of
set si 1<=i<=n.
• The brute force approach would be to form
all of these n-tuples and evaluate each one
with P, saving the optimum.
2
• The backtracking algorithm has the ability to yield
the same answer with far fewer than m-trials.
• In backtracking, the solution is built one
component at a time.
• Modified criterion functions Pi (x1...xn) called
bounding functions are used to test whether the
partial vector (x1,x2,......,xi) can lead to an optimal
solution.
• If (x1,...xi) is not leading to a solution, m i+1,....,mn
possible test vectors may be ignored. 3
• The constraints may be of two categories.
• EXPLICIT CONSTRAINTS are rules which restrict the
values of xi. Examples xi  0 or x1= 0 or 1 or li  xi  ui.
• All tuples that satisfy the explicit constraints define a
possible solution space for I.
• IMPLICIT CONSTRAINTS describe the way in which
the xi must relate to each other .
• Implicit constraints allow to find these tuples in the
solution space that satisfy the criterion function.
Example : 8 queens problem.
4
• The problem is to place eight queens on an 8 x 8
chess board so that no two queens attack i.e. no two
of them are on the same row, column or diagonal.
• Strategy : The rows and columns are numbered
through 1 to 8.
• The queens are also numbered through 1 to 8.
• Since each queen is to be on a different row
without loss of generality, we assume queen i is to
be placed on row i .
5
• The solution is an 8 tuple (x1,x2,.....,x8) where
xi is the column on which queen i is placed.
• The explicit constraints are :

Si = {1,2,3,4,5,6,7,8} 1  i  n or 1  xi  8
i = 1,.........8
• The solution space consists of 88 8- tuples.
6
The implicit constraints are :
(i) no two xis can be the same that is, all queens
must be on different columns.
(ii) no two queens can be on the same diagonal.
(i) reduces the size of solution space from 88 to 8! 8
– tuples.
Two solutions are (4,6,8,2,7,1,3,5) and
(3,8,4,7,1,6,2,5)
7
1 2 3 4 5 6 7 8
1 Q
2 Q
3 Q
4 Q
5 Q
6 Q
7 Q
8 Q 8
Solution Space :
• Tuples that satisfy the explicit constraints define a solution
space.
• The solution space can be organized into a tree.
• Each node in the tree defines a problem state.
• All paths from the root to other nodes define the state-space
of the problem.
• Solution states are those states leading to a tuple in the
solution space.
• Answer nodes are those solution states leading to an
answer-tuple( i.e. tuples which satisfy implicit constraints).
9
• The problem may be solved by systematically
generating the problem states determining which
are solution states, and determining the answer
states.
• Let us see the following terminology
• LIVE NODE A node which has been generated
and all of whose children are not yet been
generated .
• E-NODE (Node being expanded) - The live node
whose children are currently being generated .
10
• DEAD NODE - A node that is either not to
be expanded further, or for which all of its
children have been generated.
• DEPTH FIRST NODE GENERATION- In
this, as soon as a new child C of the current
E-node R is generated, C will become the
new E-node.
R will become E-node again when C has
been fully explored.
11
• BOUNDING FUNCTION - will be used to
kill live nodes without generating all their
children.
• BACTRACKING-is depth – first node
generation with bounding functions.
• BRANCH-and-BOUND is a method in
which E-node remains E-node until it is
dead.
12
• BREADTH-FIRST-SEARCH : Branch-and
Bound with each new node placed in a
queue .
The front of the queen becomes the new E-
node.
• DEPTH-SEARCH (D-Search) : New nodes
are placed in to a stack.
The last node added is the first to be
explored.
13
Example : 4 Queens problem
1 1 1 1
. . 2 2 2
3
. . . .
1 1
2
3
. , 4
14
1
x1 = 1 x1=2
2 18
x2=2 3 4 x2=1 x2=3 x2 = 4
B 3 8 13 19 24 29
x3=3 x3=4 2 3 B B
4 6 14 16 x3 = 1
x4=4 3 B 30
5 7 15 x4 = 3
B 31
15
• If (x1….xi) is the path to the current E-
node , a bounding function has the criterion
that (x1..xi+1) represents a chessboard
configuration, in which no queens are
attacking.
• A node that gets killed as a result of the
bounding function has a B under it.
16
• We start with root node as the only live node. The
path is ( ); we generate a child node 2.
• The path is (1).This corresponds to placing queen
1 on column 1 .
• Node 2 becomes the E node. Node 3 is generated
and immediately killed. (because x1=1,x2=2).
• As node 3 is killed, nodes 4,5,6,7 need not be
generated.
17
• Node 8 is generated, and the path is (1,3).
• Node 8 gets killed as all its children
represent board configurations that cannot
lead to answer. We backtrack to node 2
and generate another child node 13 .
• But the path (1,4) cannot lead to answer
nodes.
• So , we backtrack to 1 and generate the
path (2) with node 18. We observe that the
path to answer node is (2 4 1 3 )
18
GENERAL BACKTRACKING
METHOD
• All answer nodes are to be found
• If (x1…..xi) is a path from root to a node then T
(x1,….,xi) be the set of all possible values for Xi+1,
such that (x1,x2,…….,xi,xi+1) is also a path from
root to a problem state.
• B(x1…xi+1) or Bxi+1is false for the path (x1,..,xi+1) if
the path cannot reach an answer node.
• The solution vector X (1: n) are those values
which are generated by T and satisfy Bi+1.
19
METHOD (Contd..)
Procedure backtrack (n) // solution vectors are
X(1:n) and printed as soon as generated//
.//T {X(1),….X(k-1)} gives all possible values of
X(k) given that X(1),…..,X(k-1) have already
been chosen //
//The predicates Bk( X(1),….X(k-1) ) determine//
//those elements which satisfy the//
// implicit constraints//
20
METHOD (Contd..)
Procedure backtrack (n) // solution vectors are X(1:n)//
// and printed as soon as generated //
// T {X(1),….X(k-1)} gives all possible values of X(k)
// given that X(1),…..,X(k-1) have already been chosen //
// The predicates Bk (X(1),….X(k-1) ) determine those
elements //
// which satisfy the implicit constraints //
// Implicit constraints are “no two X is can be the same” //
Integer k, n; local X (1:n)
21
METHOD (Contd..)
K 1
while K > 0 do
if there remained an untried X(K) such that X(K) 
T ( X (1) , …..X(k-1) ) and Bk X (1) ,…,X(K) ) = true then
if (X (1),…, X(k) ) is a path to an answer node then
print ( X (1) ,…X (k) )
end if
K K+1 // consider next set //
else K K-1 // backtrack to previous set
endif
repeat
end Backtrack 22
EXAMPLE OF ALGORITHM WITH
4 QUEENS PROBLEMS
k 1
loop 1 X0 =1,1 {1,2,3,4} and B1 (X (1)) = true
1 is not a path to answer node
K  1+1=2
repeat K 2
loop 2
X(2){2,3,4}and B2 (1,2) is False but there
remains untried X(k)=3 and X(K) =4
23
4 QUEENS PROBLEMS (Contd..)
B2 (1,3)=true , but (1,3) Is not a path to
answer node ; so K K+1=3
There is no X(3) such that
B3(1,3,2) or B3 (1,3,4) is true .
So backtrack K K-1=2
consider X (2)  4
24
4 QUEENS PROBLEMS (Contd..)
(1,4) is not a path to answer
(1,4,2) is not a path to answer
B4(1,4,2,3)=false.
Thus X(2)=4 is false
With X(1)=1, we have seen that there is no X(2)
satisfying the constraints so KK-1=2-1=1
There remained untried X(k)=2,3,4.
Repeating with X(1)=2, we observe (2,4,1, 3) is a path to an
answer node .
Similarly the other solution is (3,1,4,2)
25
BACKTRACKING ALGORITHM
WITH RECURSION
Procedure RBACKTRACK (k)
// on entering the first K-1 values X(1),…..,X(k-1)//
// of the solution vector X(1:n) have been assigned //
global n , X(1:n)
for each X(k) such that
X(k)  T ( X (1),..X(k-1) ) and Bk (X(1)..,X(k-1), X(k) )= true do
if ( X (1) ,….,X(k) ) is a path to an answer node
then print ( X(1),……,X(k) ) end if
If (k<n)
CALL RBACKTRACK (k+1)
endif
repeat
end RBACKTRACK
26
WITH RECURSION (Contd..)
EXAMPLE (RB – RBACKTRACK)
Initially RB(1) is called
for each X(1)  X(1) {1,2,3,4} and B1 (1) is
true , but 1 is not an answer node.
RB (2) is called
X(2) {2,3,4} and B2 (1,3) = true and B2 (1,4) = true
(1,3) is not an answer node , RB(3) is called,X(3) = 2,
27
WITH RECURSION (Contd..)
but (1,3,2) is not Answer node , so , RB(4) is
called B4 (1,3,2,4) = false.
(1,3,4,2) is not bounded so , X(2) = 4 is tried
(1,4,2,3) is not bounded . With X(1)=1 no solution
Now for X(1) = 2,3,4 repeat
(2,4,1,3) is an answer node, other paths with X(1)
= 2 are not leading to answer node.
With X (1) = 3 , (3,1,4,2) is an answer node.
X (1) = 4 - no solution.
28
EFFICIENCY OF BACKTRACKING
ALGORITHM
• The time required by a backtracking
algorithm or the efficiency depends on four
factors
(i) The time to generate the next X(k);
(ii) The no. of X(k) satisfying the explicit
constraints
(iii) The time for bounding functions B i
(iv) The no. of X(k) satisfying the Bi for all i.
29
EFFICIENCY OF BACKTRACKING
ALGORITHM (BT) (Contd..)
• The first three are relatively independent of
the problem instance being solved.
• The complexity for the first three is of
polynomial complexity .
• If the number of nodes generated is 2 n , then
the worst case complexity for a
backtracking algorithm is O(P(n)2 n) where
P(n) is a polynomial in n .
30
Estimation Of Nodes generated in a
BT Algorithm
• Generate a random path in the state space tree.
• Let X be a node at level i on this path.
• Let mi be the children of X ( at level i+1 ) that do
not get bounded. (i.e. mi are the nodes which can
be considered for getting an answer node ).
• Choose randomly one of the mi.
• Continue this until this node is either is a leaf or
all its children are bounded.
31
Estimation of Nodes generated in a
BT Algorithm (Contd..)
• Let m be the no. of unbounded nodes to be
generated.
• Let us assume that the bounding functions
are static, i.e., the BT algorithm does not
change its bounding functions.
• The number of estimated number of
unbounded nodes
=1+m1+m1m2+….. +m1m2m3..mi where mi is
to be estimated no. of nodes at level i+ 1.
32
• The number of unbounded nodes on level one
is 1.
• The number of unbounded nodes on level 2 is
m1
• The total no. of nodes generated till level 2 is
1 + m1
 The total number of nodes generated till level
i+1 is 1+m1+…+m1…mi .
– The above procedure can be written as an algorithm.
33
Procedure Estimate
m1; r1; k1
loop
Tk {X (k): X(k) T ( X(1) ,….X(k-1)) and Bk (X (1), ….,
X(k))}
If size (Tk) = 0 then exit endif // SIZE returns the //
r  r * SIZE (Tk) // size of the set Tk //
m  m+r
X (k)  CHOOSE (Tk) // CHOOSE makes a random
choice of an element in Tk //
k k+1
repeat
return (m)
end estimate
34
• Then n-queens problem (8 queens problem) and
solution
• In implementing the n – queens problem we
imagine the chessboard as a two-dimensional
array A (1 : n, 1 : n).
• The condition to test whether two queens, at
positions (i, j) and (k, l) are on the same row or
column is simply to check I = k or j = l two
queens are on the same diagonal or not.
35
Estimation Of Nodes generated in a
• Let m be the no. of unbounded nodes
to be generated.
• Let us assume that the bounding
functions are static, i.e., the BT
algorithm does not change its
bounding functions .
• The number of estimated no. of
unbounded nodes
36
The n-queens problem and solution
• In implementing the n – queens problem we

imagine the chessboard as a two-dimensional
array A (1 : n, 1 : n).
• The condition to test whether two queens, at
positions (i, j) and (k, l) are on the same row or
column is simply to check I = k or j = l
• The conditions to test whether two queens are on
the same diagonal or not are to be found
37
contd..
Observe that
(1,1) (1,2) (1,3) (1,4)
i) For the elements in the
the upper left to lower (2,1) (2,2) (2,3) (2,4)
Right diagonal, the row -
column values are same (3,1) (3,2) (3,3) (3,4)
or row- column = 0,
e.g. 1-1=2-2=3-3=4-4=0 (4,1) (4,2) (4,3) (4,4)
ii) For the elements in the upper right to the lower left
diagonal, row + column value is the same e.g.
1+4=2+3=3+2=4+1=5
38
contd..
• Thus two queens are placed at
positions (i, j) and (k, l), then they are
on the same diagonal only if
i – j = k - l or i + j = k+l
or j - l = i - k or j - l = k - i
• Two queens lie on the same diagonal if and
only if
|j – l| = |i - k|
39
The n-queens problem -Algorithm
Procedure PLACE (k)
//returns true if a queen can be placed in the kth row
and X(k)th column w.r.t.already placed rows 1..k-1//
global X (1:k); integer i, k
for i  1 to k-1 do
// test if X (k) is on the same column or same//
//diagonal with any of X(1) ….X(k-1)//
40
contd..
if X(i) = X(k)// two are in the same column//
or ABS(X(i) –X(k)) = ABS(i-k) // in the same diagonal //
then Return (false)
end if
repeat
return (true)
end PLACK
Above procedure is used in the solution to n queens
problem
41
contd..
Procedure N queens(n)
//solves n queens problem, gives all solutions //
integer k,n; X(1:n)
X(1) 0 ; k1 // k is the current row,//
//X(k) is the current column //
while k > 0 do
X(k)  X(k) + 1 // move to the next column //
42
contd..
While X(k)  n and not PLACE(k)
// queen k cannot be placed at X(k) th column //
X(k)  X(k) + 1 // move to the next column //
repeat
if X(k)  n // place(k) is true i.e.a position X(k) //
//is found for queen k //
then if k = n // Is a solution complete ? //
then print(X)
43
contd..
else k  k+1;
X(k) = 0; //compute next component X (k) //
endif
else // no X(k) is suitable for placing queen k //
k k-1 //backtrack//
endif
repeat
end NQUEENS
44
The n-queens problem –Algorithm
with example
Example :
k1, X (1)  0
k > 0 so X(1)  0+1 = 1
Place (1) is true so queen 1
is placed in X(1) = 1st column
X(1)  4 but 1  4 so k1+1=2, X(2)0
while loop is repeated
X(2) 0+1=1
X(2)  4 and PLACE (2) is false
as X(1)=1=X(2) =1
PLACK(3) is true 45
GRAPH COLOURING
PROBLEM
• Let G be a graph and m be a positive integer .
• The problem is to colour the vertices of G using
only m colours in such a way that no two adjacent
nodes / vertices have the same color.
• It is necessary to find the smallest integer m.
m is referred to as the chromatic number of G.
• A special case of graph colouring problem is the
four colour problem for planar graphs .
46
GRAPH COLOURING
PROBLEM (Contd..)
• A graph is planar iff it can be drawn in a
plane in such a way that no two edges cross
each other.
• 4- colour problem for planar graphs Given
any map, can the regions be coloured in
such a way that no two adjacent regions
have the same colour with only four
colours?
47
GRAPH COLOURING
PROBLEM (Contd..)
• A map can be transformed into a graph by
representing each region of map into a node and if
two regions are adjacent, then the
corresponding nodes are joined by an edge.
• For many years it was known that 5 colours are
required to colour any map.
• After a several hundred years,
mathematicians with the help of a computer
showed that 4 colours are sufficient.
48
GRAPH COLOURING
PROBLEM (Contd..)
4 5 1
2
1 2 3
3
5 4
(a) (b)
A map (a) and its planar graph (b) representation
49
Solving the Graph Colouring
Problems
• The graph is represented by its
adjacency matrix Graph (1:n,1:n) where
GRAPH (i,j) = true if <i,j> is an edge
and Graph (i,j) = false otherwise.
• The colours will be represented by the
integers 1,2….m and the solution with
n–tuple (X(1),….X(n)), where X(i) is the
colour of node i.
50
Problems (Contd..)
• The solution can be represented as a
state space tree.
• Each node at level i has m children
corresponding to m possible
assignments to X(i) 1≤i≤m.
• Nodes at level n+1, are leaf nodes. The
tree has degree m with height n+1.
51
State space tree for m colouring problem with
n = 3 and m = 3
1
X(1)=1 X(1)=3
X(1)=2
2
X(2)=1
2 3
3
X(3)=1
2 3
4 5 6
52
Graph Colouring Problem-
Algorithm
Procedure MCOLORING (k)
// Recursive backtracking for//
// graph colouring problem //
// k is the index of the next vertex to colour //
global integer m,n,X(1:n);
boolean GRAPH (1:n,1:n)
integer k
loop //generates values for X(k) //
53
Problems (Contd..)
Call NEXTVALUE(K) // assign to X(k) a legal colour //
if X(k) = 0 then exit endif
// no new colour is possible //
if k = n then Print X
// m colours are assigned to n vertices //
else call MCOLOURING(k+1)
endif
repeat
end MCOLOURING
54
Problems (Contd..)
Procedure NEXTVALUE(k)
// X(1)….X(k-1) have been assigned //
// to vertices 1,…k-1 //
// X(k) is the next highest numbered //
colour different from those adjacent to k //
global integer m,n X(1:n)
boolean GRAPH(1:n,1:n)
integer j,k
55
Problems (Contd..)
loop
X(k)( X(k) +1 ) mod(m+1)
//next highest colour//
if X(k)=0 then return endif
//All colours have been exhausted//
for j 1 to n do
//Check if this colour is distinct from //
//adjacent colours//
56
Problems (Contd..)
if GRAPH(k,j) and // if (k,j) is an edge //
X(k)=X(j)
then exit endif
repeat
if j = n+1 then return endif
// the loop is exited with the last value //
// i.e. j = n+1 and hence new colour is found //
repeat // try to find another colour //
end NEXTVALUE
57
Problems (Contd..)
Example for NEXTVALUE(k) 1
Let m = 3 n = 4 2
Nextvalue(1) 4
X(1)=(0+1) mod 4 =1 3
for j1 to 4 initially
1≠0 so j=5 so return X(1)=X(2)=X(3)
Nextvalue(2) returns (0+1)mod4=1 =X(4)=0
but X(2)=X(1) for j=1 and j≠5 so
loop is repeated and Nextvalue(2) is 2
Similarly Next value(3) is 3 and
Next value (4) is 2
58
HAMILTONIAN CYCLES
• Let G=(V,E) be a connected graph with n
vertices .
• A Hamiltonian cycle is a round path along n
edges of G which visits every vertex once
and returns to its starting position.
• The tour of a traveling salesperson problem is
a Hamiltonian cycle.
• A tour may exist or not.
59
HAMILTONIAN CYCLES
(Contd..)
1 2 3 4 1 2 3
8 7 6 5 5 4
(a) (b)
Hamiltonian Cycle is 1,2,8,7,6,5,4,3,1 No Hamiltonian Cycle
60
HAMILTONIAN CYCLES
(Contd..)
• The backtracking solution is a vector (x 1,……,xn)
where xi represents the ith visited vertex of the
cycle.
• To avoid printing of the same cycle n times we
require X(1) = 1 (as 128765431, 287654312,
87654312)
• We compute X(k) given (x1…..xk-1) have already
been chosen.
• Two procedures NEXTVALUE(k) and
HAMILTONIAN are used,to find the tour.
• We initialize Graph (1:n,1:n) and X(2:n)0,
X(1)1 and start with HAMILTONIAN (2).
61
HAMILTONIAN CYCLES -Algorithm
Procedure HAMILTONIAN(k)
// uses recursive backtracking //
// All the H- cycles are to be found //
// All cycles begin at vertex 1//
global integer X(1:n)
local integer k,n
loop // generate values for X(k) //
62
(Contd..)
call NEXTVALUE(k)
// assign a legal vertex to X(k) //
if X(k)=0 then return endif
if k = n
then print (X, ’1’)
// a cycle is printed //
else print (HAMILTONIAN (K+1))
endif
repeat
end HAMILTONIAN
63
(Contd..)
Procedure NEXTVALUE(k)
// X(1) ,.,x(k-1) is a path of k-1vertices,//
//X(k) is the next highest value vertex,//
//X(k) = 0 means, no vertex has been //
//assigned to X(k) //
global integer n,X(1:n);
boolean GRAPH(1:n,1:n)
integer k, j
64
(Contd..)
loop
X(k) (X(k)+1) mod(n+1) // next vertex //
if X(k) = 0 then return endif
if GRAPH (X(k-1),X(k)) // if there is an edge //
then for j1 to k-1 do
// check whether the same vertex is generated //
if X(j) = X(k)
then exit // for loop exit //
endif
repeat // for //
65
(Contd..)
if j = k // the for loop is exited with //
// last value I.e. j = k –1+1 = k //
then
if k < n or (k = n and GRAPH(X(n),1))
then return endif
endif
endif
repeat
end NEXTVALUE
66
Example
Example:
Let n = 8
X(1) = 1, HAMILTONIAN(2) i.e.H(2)
is called, so NEXTVALUE(2) i.e.N(2) is called.
Initially X(2)=0
X(2)=0+1 mod 9 = 1 but X(1) = X(2)
so loop is repeated and X(2) = 2 mod 9 = 2
X(1)≠X(2) and j=k=2, k < 8 so return 2
NV(3)=8 as Graph(2,3), Graph(2,5)
67
HAMILTONIAN CYCLES
-Algorithm Example contd..
Graph(2,6),Graph(2,7),Graph(2,4) are
false.
Thus NV(4) = 7,NV(5) = 6,NV(6) = 5
NV(7) = 4, NV(8) = 3.
At NV(8), k = 8 and GRAPH(X(8),1)
is satisfied. Thus
The cycle is printed.
68

Backtracking: General Method

Uploaded by

Copyright:

Available Formats

Backtracking: General Method

Uploaded by

Document Information

Original Title

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

Backtracking: General Method

Uploaded by

Copyright:

Available Formats

BACKTRACKING

• The explicit constraints are :

• In implementing the n – queens problem we

You might also like