Backtracking

Backtracking is a systematic way to go through all the possible configurations of a space. These configurations may be all possible arrangements of objects or all possible ways of building a collection of them.

We must generate each oe of the possible confgurations exactly once systematically. We represent our configurations by a vector A = (a₁, a₂, ... , a_n) , where each element a_i is selected from an ordered set of possible candidates S_i for position i.

Algorithm:

Backtrack (A)
Compute S₁, the set of candidate first elements of solution A.
k=1
while k > 0 do
while S_k not empty do
a_k = the next element from S_k
S_k = S_k - a _k
if A = (a₁, a₂, ... , a_k) is a solution, report it.
k = k + 1
compute S_k, the set of candidate kth elements of solution A.
k = k - 1

Since each solution can be thought of as a traversal of a tree, we can use a Depth-first Traversal to yield a recursive algorithm.

Backtrack-DFS (A,k)

if A = (a₁, a₂, ... , a_k) is a solution, report it.
else
k = k + 1
compute S_k
while S_k not empty do
a_k = an element in S_k
S_k = S_k - a _k
Backtrack(a,k)

Subset Example:

To construct all 2ⁿ subsets, we set S_k = (true, false) and A is a solution whenever k >= n. Thus, each solution vector has size n and consists of a series of true or falses. We will use the number i to represent a true value for the ith position and a - to represent false.

Backtrack (A)
S₁=(true, false)
k=1
while k > 0 do
while S_k not empty do
a_k = the next element from S_k
S_k = S_k - a _k
if A = (a₁, a₂, ... , a_k) is a solution, report it.
k = k + 1
S_k= (true, false)
k = k - 1
       

Permutation Example:

To construct all n! permutaions, we set S_k = {1, 2, ..., n} - A and A is a solution whenever k = n + 1. Thus, each solution vector has size n and consists of a series of numbers.

Backtrack (A)
S₁= {1, 2, ..., n}
k=1
while k > 0 do
while S_k not empty do
a_k = the next element from S_k
S_k = S_k - a _k
if A = (a₁, a₂, ... , a_k) is a solution, report it.
k = k + 1
S_k= {1, 2, ..., n} - A
k = k - 1