Concept of Branch and bound Method:

Branch and bound (BB, B&B, or BnB) is a method for solving optimization problems by
breaking them down into smaller sub-problems and using a bounding function to eliminate sub-
problems that cannot contain the optimal solution. It is an algorithm design
paradigm for discrete and combinatorial optimization problems, as well as mathematical
optimization. A branch-and-bound algorithm consists of a systematic enumeration of candidate
solutions using state space search: the set of candidate solutions is thought of as forming a rooted
tree with the full set at the root. The algorithm explores branches of this tree, which represent
subsets of the solution set. Before enumerating the candidate solutions of a branch, the branch is
checked against upper and lower estimated bounds on the optimal solution and is discarded if it
cannot produce a better solution than the best one found so far by the algorithm.

The algorithm depends on efficient estimation of the lower and upper bounds of
regions/branches of the search space. If no bounds are available, the algorithm degenerates to an
exhaustive search.

The method was first proposed by Ailsa Land and Alison Doig whilst carrying out research at
the London School of Economics sponsored by British Petroleum in 1960 for discrete
programming, and has become the most commonly used tool for solving NP-hard optimization
problems. The name "branch and bound" first occurred in the work of Little et al. on
the traveling salesman problem.

The goal of a branch-and-bound algorithm is to find a value x that maximizes or minimizes the
value of a real-valued function f(x), called an objective function, among some set S of
admissible, or candidate solutions. The set S is called the search space, or feasible region. The
rest of this section assumes that minimization of f ( x ) is desired; this assumption comes without
loss of generality, since one can find the maximum value of f(x) by finding the minimum of
g(x )=−f (x) . A B&B algorithm operates according to two principles:

It recursively splits the search space into smaller spaces, then minimizing f ( x ) on these smaller
spaces; the splitting is called branching.

Branching alone would amount to brute-force enumeration of candidate solutions and testing
them all. To improve on the performance of brute-force search, a B&B algorithm keeps track
of bounds on the minimum that it is trying to find, and uses these bounds to "prune" the search
space, eliminating candidate solutions that it can prove will not contain an optimal solution.

Turning these principles into a concrete algorithm for a specific optimization problem requires
some kind of data structure that represents sets of candidate solutions. Such a representation is
called an instance of the problem. Denote the set of candidate solutions of an instance I by SI.
The instance representation has to come with three operations:

branch(I) produces two or more instances that each represent a subset of SI. (Typically, the
subsets are disjoint to prevent the algorithm from visiting the same candidate solution twice, but
this is not required. However, an optimal solution among SI must be contained in at least one of
the subsets.[6])
bound(I) computes a lower bound on the value of any candidate solution in the space represented
by I , that is, bound(I) ≤ f (x )for all x in SI.

solution(I) determines whether I represents a single candidate solution. (Optionally, if it does not,
the operation may choose to return some feasible solution from among SI.[6])
If solution(I) returns a solution then f(solution(I)) provides an upper bound for the optimal
objective value over the whole space of feasible solutions.

Using these operations, a B&B algorithm performs a top-down recursive search through
the tree of instances formed by the branch operation. Upon visiting an instance I, it checks
whether bound(I) is equal or greater than the current upper bound; if so, I may be safely
discarded from the search and the recursion stops. This pruning step is usually implemented by
maintaining a global variable that records the minimum upper bound seen among all instances
examined so far.

Algorithm:
Step 1: Initialization

Consider the following all integer programming problem

Maximize Z=c 1 x 1+ c 2 x 2+. . .+cn xn

Subject to the constraints

a 11 x 1 +a 12 x 2+. . .+a1 n x n=b1

a 21 x 1+ a22 x 2 +. ..+ a2 n x n=b2 … … … … … … … … … … … … … … … … … … … … … …(LP−A )

a m 1 x 1+ am 2 x2 +. . .+a m n x n=b m

and xj ≥0 and non-negative integers.

Obtain the optimal solution of the given LP problem ignoring integer restriction on the variables.

(i) If the solution to this LP problem (say LP-A) is infeasible or unbounded, the solution to the
given all-integer programming problem is also infeasible or unbounded, as the case may be.

(ii) If the solution satisfies the integer restrictions, the optimal integer solution has been obtained.
If one or more basic variables do not satisfy integer requirement, then go to Step 2. Let the
optimal value of objective function of LP-A be Z1 . This value provides an initial upper bound on
objective function value and is denoted by ZU ..

(iii) Find a feasible solution by rounding off each variable value. The value of objective function
so obtained is used as a lower bound and is denoted by Z 0.
Step 2: Branching step

(i) Let x k be one basic variable which does not have an integer value and also has the largest
fractional value.

(ii) Branch (or partition) the LP-A into two new LP subproblems (also called nodes) based on
integer values of x k that are immediately above and below its non-integer value. That is, it is
partitioned by adding two mutually exclusive constraints:

xk ≤[ xk ] and xk ≥[ xk ]+1

to the original LP problem. Here [ x¿¿ k ]¿ is the integer portion of the current non-integer value
of the variable x k . This is obviously is done to exclude the non-integer value of the variable x k .
The two new LP subproblems are as follows:

LP Subproblem B LP Subproblem C
n n
Max Z=∑ c j x j Max Z=∑ c j x j
j=1 j=1

n n
Subject to ∑ aij x j =¿ b j ¿ Subject to ∑ aij x j =¿ b j ¿
j=1 j=1

x k ≤ [x k ] x k ≤ [x k ]

And x j ≥ 0 And x j ≥ 0

Step 3: Bound step

Obtain the optimal solution of subproblems B and C. Let the optimal value of the objective
function of LP-B be Z 2and that of LP-C be be Z3 . The best integer solution value becomes the
lower bound on the integer LP problem objective function value (Initially this is the rounded off
value). Let the lower bound be denoted by be Z L.

Step 4: Fathoming step

Examine the solution of both LP-B and LP-C

(i) If a subproblem yields an infeasible solution, then terminate the branch.

(ii) If a subproblem yields a feasible solution but not an integer solution, then return to Step 2.
(iii) If a subproblem yields a feasible integer solution, examine the value of the objective
function. If this value is equal to the upper bound, an optimal solution has been reached. But if it
is not equal to the upper bound but exceeds the lower bound, this value is considered as new
upper bound and return to Step 2. Finally, if it is less than the lower bound, terminate this branch.

Step 5: Termination

The procedure of branching and bounding continues until no further sub-problem remains to be
examined. At this stage, the integer solution corresponding to the current lower bound is the
optimal all-integer programming problem solution.

Remark

The above algorithm can be represented by an enumeration tree. Each node in the tree represents
a subproblem to be evaluated. Each branch of the tree creates a new constraint that is added to
the original problem.