NPTEL MOOC

PROGRAMMING, 

DATA STRUCTURES AND
ALGORITHMS IN PYTHON
Week 6, Lecture 1

Madhavan Mukund, Chennai Mathematical Institute

http://www.cmi.ac.in/~madhavan
Backtracking

Systematically search for a solution

Build the solution one step at a time

If we hit a dead-end

Undo the last step

Try the next option

Eight queens

Place 8 queens on a chess

board so that none of them
attack each other

In chess, a queen can

move any number of
squares along a row
column or diagonal
Eight queens

Place 8 queens on a chess

board so that none of them
attack each other Q

In chess, a queen can

move any number of
squares along a row
column or diagonal
Eight queens

Place 8 queens on a chess

board so that none of them
attack each other Q

In chess, a queen can

move any number of
squares along a row
column or diagonal
Eight queens

Place 8 queens on a chess

board so that none of them
attack each other Q

In chess, a queen can

move any number of
squares along a row
column or diagonal
N queens

Place N queens on an


N x N chess board so that
none attack each other

N = 2, 3 impossible
N queens

Place N queens on an
 Q

N x N chess board so that Q
none attack each other

N = 2, 3 impossible
N queens

Place N queens on an
 Q

N x N chess board so that Q
none attack each other

N = 2, 3 impossible
Q
N = 4 is possible Q
Q
Q
N queens

Place N queens on an
 Q

N x N chess board so that Q
none attack each other

N = 2, 3 impossible
Q
N = 4 is possible Q
Q
And all bigger N as well Q
8 queens
Clearly, exactly one queen
in each row, column

Place queens row by row

In each row, place a queen

in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column

Place queens row by row

In each row, place a queen

in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row

In each row, place a queen

in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q

In each row, place a queen

in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q
Q
In each row, place a queen
in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q
Q
In each row, place a queen Q
in the first available column
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q
Q
In each row, place a queen Q
in the first available column Q
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q
Q
In each row, place a queen Q
in the first available column Q
Q
8 queens
Clearly, exactly one queen Q
in each row, column
Q
Place queens row by row Q
Q
In each row, place a queen Q
in the first available column Q
Q
Can’t place a queen in the
8th row!
8 queens
Can’t place the a queen in Q
the 8th row!
Q
Q
Q
Q
Q
Q
8 queens
Can’t place the a queen in Q
the 8th row!
Q
Undo 7th queen, no other Q
choice Q
Q
Q
8 queens
Can’t place the a queen in Q
the 8th row!
Q
Undo 7th queen, no other Q
choice Q
Q
Undo 6th queen, no other
choice
8 queens
Can’t place the a queen in Q
the 8th row!
Q
Undo 7th queen, no other Q
choice Q

Undo 6th queen, no other

choice

Undo 5th queen, try next

8 queens
Can’t place the a queen in Q
the 8th row!
Q
Undo 7th queen, no other Q
choice Q
Q
Undo 6th queen, no other
choice

Undo 5th queen, try next

Backtracking

Keep trying to extend the next solution

If we cannot, undo previous move and try again

Exhaustively search through all possibilities

… but systematically!
Coding the solution
How do we represent the board?

n x n grid, number rows and columns from 0 to n-1

board[i][j] == 1 indicates queen at (i,j)

board[i][j] == 0 indicates no queen

We know there is only one queen per row

Single list board of length n with entries 0 to n-1

board[i] == j : queen in row i, column j, i.e. (i,j)

Overall structure
def placequeen(i,board): # Trying row i

for each c such that (i,c) is available:

place queen at (i,c) and update board

if i == n-1:

return(True) # Last queen has been placed

else:

extendsoln = placequeen(i+1,board)

if extendsoln:

return(True) # This solution extends fully

else:

undo this move and update board

else:

return(False) # Row i failed
Updating the board
Our 1-D and 2-D representations keep track of the
queens

Need an efficient way to compute which squares are

free to place the next queen

n x n attack grid

attack[i][j] == 1 if (i,j) is attacked by a queen

attack[i][j] == 0 if (i,j) is currently available

How do we undo the effect of placing a queen?

Which attack[i][j] should be reset to 0?

Updating the board
Queens are added row by row

Number the queens 0 to n-1

Record earliest queen that attacks each square

attack[i][j] == k if (i,j) was first attacked by

queen k

attack[i][j] == -1 if (i,j) is free

Remove queen k — reset attack[i][j] == k to -1

All other squares still attacked by earlier queens

Updating the board

attack requires n2 space

Each update only requires O(n) time

Only need to scan row, column, two diagonals

Can we improve our representation to use only

O(n) space?
A better representation
How many queens attack row i?

How many queens attack row j?

An individual square (i,j) is attacked by upto 4

queens

Queen on row i and on column j

One queen on each diagonal through (i,j)

Numbering diagonals
Decreasing diagonal:
0 1 2 3 4 5 6 7
column - row is invariant
0
1 c-r=2
2
3
4
5
6
7
Numbering diagonals
Decreasing diagonal:
0 1 2 3 4 5 6 7
column - row is invariant
0
1
2
3
4
5 c-r=-4
6
7
Numbering diagonals
Decreasing diagonal:
0 1 2 3 4 5 6 7
column - row is invariant
0
Increasing diagonal:
 1
column + row is invariant 2
c+r=6
3
4
5
6
7
Numbering diagonals
Decreasing diagonal:
0 1 2 3 4 5 6 7
column - row is invariant
0
Increasing diagonal:
 1
column + row is invariant 2
3
4
5 c+r=12
6
7
Numbering diagonals
Decreasing diagonal:
0 1 2 3 4 5 6 7
column - row is invariant
0
Increasing diagonal:
 1
column + row is invariant 2
3
(i,j) is attacked if

4
row i is attacked
5 c+r=12
column j is attacked
6
diagonal j-i is attacked
7
diagonal j+i is attacked
O(n) representation

row[i] == 1 if row i is attacked, 0..N-1

col[i] == 1 if column i is attacked, 0..N-1

NWtoSE[i] == 1 if NW to SE diagonal i is


attacked, -(N-1) to (N-1)

SWtoNW[i] == 1 if SW to NE diagonal i is


attacked, 0 to 2(N-1)
Updating the board
(i,j) is free if
row[i]==col[j]==NWtoSE[j-i]==SWtoNE[j+i]==0
Add queen at (i,j)
board[i] = j

(row[i],col[j],NWtoSE[j-i],SWtoNE[j+i]) =

(1,1,1,1)
Remove queen at (i,j)
board[i] = -1

(row[i],col[j],NWtoSE[j-i],SWtoNE[j+i]) =

(0,0,0,0)
Implementation details
Maintain board as nested dictionary

board['queen'][i] = j : Queen located at (i,j)

board['row'][i] = 1 : Row i attacked

board['col'][i] = 1 : Column i attacked

board['nwtose'][i] = 1 : NWtoSW diagonal i

attacked

board['swtone'][i] = 1 : SWtoNE diagonal i

attacked
Overall structure
def placequeen(i,board): # Trying row i

for each c such that (i,c) is available:

place queen at (i,c) and update board

if i == n-1:

return(True) # Last queen has been placed

else:

extendsoln = placequeen(i+1,board)

if extendsoln:

return(True) # This solution extends fully

else:

undo this move and update board

else:

return(False) # Row i failed
All solutions?

def placequeen(i,board): # Try row i


for each c such that (i,c) is available:

place queen at (i,c) and update board

if i == n-1:

record solution # Last queen placed

else:

extendsoln = placequeen(i+1,board)

undo this move and update board