Backtracking

I. Introduction

I. Introduction

• Backtracking is a systematic method for generating all (or subsets of) combinortial objects.

• Examples of combinatorial objects include

  1. Binary strings of n bits

  2. Subsets of a given set E of n elements

  3. Directed graphs of n nodes

  4. Undirected graphs of n nodes

  5. Permutations of a given size n

  6. Hamiltonian cycles of a given graph

  7. K-cliques of a given graph

  8. K-colorings of a given graph

II. Formulation of the Problem of Generating Combinatorial Objects

• In most of the generation problems, we have

  1. Each object is represented by an array X[1:N]

  2. The elements of the array are taken from a domain S={a₁,a₂,...,a_m}. Often, S is a finite set of successive integers.

  3. The values of array X must satisfy some constraints C so that X represents a legitimate object of the type in question.

• We will show the specifics in each of the following instances of combinatorial object generation

• Problem 1: Generation of all n-bit binary strings

  • Every n-bit binary string is represented by an array X[1:n]

  • X[i] takes its values from {0,1}

  • The constrainst C are empty because the values of the individual bits are indepedent

• Problem 2: Generation of all subsets of the set {1,2,...,n}

  • Every subset is represented by the bitmap (i.e., Boolean array) X[1:n];

  • X[i] takes its values from {0,1}.
    X[i]=1 if i is in the subset being represented;
    X[i]=0 if i is not in the subset being represented.

  • The constrainst C are empty because whether i is an element of the subset has no bearing on whether or not j is an element of the subset.

• Problem 3: Generation of all directed graphs of n nodes

  • Every digraph of n nodes is representable by a 2D array A[1:n,1:n], which is the well-known adjacency matrix.

  • The values of the entries in the array are binary and also are independent of one another.

  • The 2D array can be represented by a a 1D binary array X[1:N] where N=n²

  • The value of each X[i] is in {0,1}

  • The constraints C are empty because the values of entries of X (which are the entries of A) are independent

  • Mapping from A to X: Stack the rows of A one after another. Thus, X[(i-1)n + j] = A[i,j]

• Problem 4: Generation of all undirected graphs of n nodes

  • Every graph of n nodes is also representable by the 2D adjacency matrix A[1:n,1:n].

  • The values of the entries in the array are binary but are not independent of one another: A[i,j] = A[j,i] for all i and j Which is the symmetry contraint (or property)

  • The 2D array can be represented by a a 1D binary array X[1:N] where N=n², like in the case of directed graphs, but this time with the symmetry constraint.

  • A preferable alternative is to only represent the upper triangle only, and thus eliminate the constraints as follows.

  • Map the upper triangle of A into a 1D binary array X[1:N], N=n(n-1)/2:
    A[1,2:n] goes first into X
    A[2,3:n] goes next into X
    A[3,4:n] goes next into X
    .
    .
    .
    A[n-1,n] goes last into X

  • The value of each X[i] is in {0,1}

  • The constraints C are back to being empty.

• Problem 5: Generation of all permutations of {1,2,...,n}

  • A permutation is a one-to-one and onto mapping (function) f from {1,2,...,n} to {1,2,...,n}. The mapping of element i is denoted f(i).

  • Another definition: A permutation is a re-ordering (re-arrangement) of the elements 1,2,...,n

  • A third defintion: A permutation is a one-to-one matching. i is said to be matched with f(i).

  • A permutation f can be represented by an array X[1:n] where X[i]=f(i).

  • X[i] takes its elements from {1,2,...,n}

  • Constraints: X[i] != X[j] for all i != j

• Problem 6: Generation of all Hamiltonian cycles in a given graph G=(V,E) of n nodes

  • A Hamiltonian cycle is a cycle that goes through every node of the graph exactly once. Note that not all graphs have Hamiltonian cycles.

  • A Hamiltonian cycle can be represented by an array X[1:n] where X[i] is the label of the i-th node in the cycle.

  • Each X[i] takes its elements from {1,2,...,n}, which are the labels of the nodes.

  • Constraints:
    1. X[i] != X[j] for all i != j
    2. (X[i],X[i+1]) is an edge for every i=1,2,...n-1, and (X[n],X[1]) is also an edge.

• Problem 7: Generation of all k-cliques in a given graph G=(V,E) of n nodes, where k is an integer, 1 <= k <= n

  • A k-clique in a graph G is a subset of k nodes where every pair of those nodes are adjacent in G.

  • A k-clique is representable by an array X[1:k], where X[i] is the label of the i-th node in the k-clique.

  • Each X[i] takes its elements from {1,2,...,n}, which are the labels of the nodes.

  • Constraints:
    1. X[i] != X[j] for all i != j
    2. (X[i],X[j]) is an edge for every i and j

• Problem 8: Generation of all k-colorings of a given graph G=(V,E) of n nodes, where k is an integer, 1 <= k <= n

  • A k-coloring of G is an assignment of a color to each node in such a way that every two neighboring nodes have distinct colors, and the total number of colors used is <= k. The colors can be conveniently labeled 1,2,...,k.

  • A k-coloring can be represented by an array X[1:n] where X[i] is the color of node i.

  • Each X[i] takes its values from the set of colors {1,2,...,k}

  • Constraints: If (i,j) is an edge in G, then X[i] != X[j]

III. The General Backtracking Algorithm

• The algorithm will generate all valid arrays X[1:N] whose elements come from the domain S={a₁,a₂,...,a_m} of successive integers, such that the constraints C are satisfied.

• The algorithm is a depth-first search like traversal (or generation) of the tree that represents the entire solution space.

• In the tree, the root designates the starting point, and every path from the root to a leaf is of length N, where the i-th node in level specifies a value for element X[i]. The whole path corresponds to the whole array and represents a single solution, that is, a single object.

  During the generation of the tree, when we are to create a new node corresponding to X[i], we try to assign X[i] a new the next domain value (given the current value of X[i] as reference).
  

  If that value does not violate the constraints C, it is assigned.

  If, on the other hand, that value violates C, the next value after that is tried, and so on until either a C-compliant value is found or all remaining values are exhausted.

  If a C-compliant value is found and assigned to X[i], we move to the next level to find a value for X[i+1].

  If no C-compliant remaining value is found for X[i], we backtrack to the previous level to find a new value for X[i-1].

  When we backtrack to the root, the whole tree has been fully generated, and the algorithm stops.

• Whenever a C-compliant value for X[n] is found, a complete new object has been generated, and the path from the root to that node corresponding to X[n] is printed out as the object.

• Note that in the algorithm, when a new node and a new value for X[i] is being generated, the values that are tried are the "next" values from a reference value, which is the current value of X[i].

  At the outset, the reference value is initialized be a value a₀ = a₁ - 1.

  That way, the next value is always the reference (current) value + 1.

• The full algorithm follows:

  
  
  Procedure Backtrack()
  begin
     Integer r := 1;  -- r is the tree level, or index of X
     Integer X[1:N];
  
     for i=1 to N do 
        X[i] := a0;
     endfor
  
     while r > 0 do 
        getnext(X,r);   -- assigns to X[r] its next 
  		      -- C-compliant value, if available.
  		      -- Otherwise, it re-initlizes X[r] 
  		      -- to a0
        if (X[r] = a0) then
        	 r := r-1; -- backtrack to the previous level
        elseif r=N
  	 print(X[1:N]); -- a new complete solution
        else
  	 r := r+1; -- move to the next level for X[r+1]
        endif
     endwhile
  end
  
  
  

  
  
  Procedure getnext(input/output: X[1:N]; input: r)
  begin
     X[r] := X[r] + 1;	-- next tentative value
     while (X[r] is still in the domain) do 	
        if (Bound(X[1:N],r) is true) then
  	 return;
        else
  	 X[r] := X[r] + 1;
        endif
     endwhile
  
     -- if getnext has not returned,
     -- that mean no C-compliant remaining
     -- value was found. Re-initialize X[r]
     X[r] := a0;
  end
  
  
  

• The Bound function checks to see if the constraints C are sastified. The actual implementation of Bound is problem-dependent.

• In every backtracking problem, you need to do the following:

  1. Represent the object by an array X[1:N], specifying N, what each X[i] signifies, what the domain of each X[i] is, the value of a₀, and the constraints C.

  2. Implement the Bound function

IV. Implementations for the Eight Applications

• Problems 1-4: Binary Strings, Subsets, Digraphs, and Undirected Graphs

  • a₀ = -1.

  • Bound simply returns true, because C is empty.

• Problem 5: Generation of all permutations of {1,2,...,n}

  • a₀ = 0

  • Bound function:

    
    
    Function Bound(X[1:n],l)
    begin
       /* X[1:l-1] are assigned C-compliant 
    	values. This function checks to 
    	see if X[l] is C-compliant */
       for i=1 to l-1 do
          if X[l] = X[i] then
    	 return(false);
          endif
       endfor
    
       return(true);
    end
    
    
    

• Problem 6: Generation of all Hamiltonian cycles in a given graph G=(V,E) of n nodes

  • a₀ = 0

  • Bound function:

    
    
    Function Bound(X[1:n],l)
    begin
       /* X[1:l-1] are assigned C-compliant 
    	values. This function checks to 
    	see if X[l] is C-compliant */
       for i=1 to l-1 do
          if X[l] = X[i] then
    	 return(false);
          endif
       endfor
    
       if (l > 1 and (X[l-1],X[l]) is not an edge) then
          return(false);
       endif
    
       if (l=n and (X[n],X[1]) is not an edge) then
          return(false);
       endif
    
       return(true);
    end
    
    
    

• Problem 7: Generation of all k-cliques in G

  • a₀ = 0

  • Bound function:

    
    
    Function Bound(X[1:n],l)
    begin
       /* X[1:l-1] are assigned C-compliant 
    	values. This function checks to 
    	see if X[l] is C-compliant */
       for i=1 to l-1 do
          if X[l] = X[i] then
    	 return(false);
          elseif (X[l],X[i]) is not an edge
    	 return(false);
          endif
       endfor
    
       return(true);
    end
    
    
    

• Problem 8: Generation of all k-colorings of a given graph G=(V,E) of n nodes, where k is an integer, 1 <= k <= n

  • a₀ = 0

  • Bound function:

    
    
    Function Bound(X[1:n],l)
    begin
       /* X[1:l-1] are assigned C-compliant 
    	values. This function checks to 
    	see if X[l] is C-compliant */
       for i=1 to l-1 do
          if ((l,i) is an edge and
    		X[l] = X[i]) then
    	 return(false);
          endif
       endfor
    
       return(true);
    end
    
    
    

• Time Complexity:

  • Bound and getnext take O(1) in the first 4 problems. Backtrack takes O(nx(number of objects)):O(n2N) where N=n,n,n², and n(n-1)/2, respectively.

  • In Problems 5 and 6, Bound takes O(n), getnext takes O(n²), and Backtrack takes O(nxn²xn!)=O(n³xn!).

  • In Problem 7 (k-clique), Bound takes O(k), getnext takes O(nk), and Backtrack takes O(nk x n^k)

  • In problem 8 (coloring), Bound takes O(n), getnext takes O(nk), and Backtrack takes o(nk x n^k)

  • Therefore, Backtracking is never applied to generate all objects for large object sizes. Rather, a selected and small subset of objects is generated, often by tweaking the algorithm so it generates a random subset of objects used for testing purposes.