Branch and bound

From Wikipedia, the free encyclopedia

Branch and bound is a general algorithmic method for finding optimal solutions of various optimization problems, especially in discrete and combinatorial optimization. It is basically an enumeration approach in a fashion that prunes the nonpromising search space.

The method was first proposed by A. H. Land and A. G. Doig in 1960 for linear programming.

1 General description
2 Applications
3 References
4 See also

[edit] General description

The general idea may be described in terms of finding the minimal or maximal value of a function $f (x)$ over a set of admissible values of the argument $x$ called feasible region. In practice, minimization is applied when the function represents a cost, while maximization is applied when the function represents a value. Both $f$ and $x$ may be of arbitrary nature. A branch-and-bound procedure requires two tools.

The first one is a smart way of covering the feasible region by several smaller feasible subregions (ideally, splitting into subregions). This is called branching, since the procedure may be repeated recursively to each of the subregions and all produced subregions naturally form a tree structure, called search tree or branch-and-bound-tree or something similar. Its nodes are the constructed subregions.

Another tool is bounding, which is a fast way of finding upper and lower bounds for the optimal solution within a feasible subregion.

For a given problem space an efficient division will divide the solution space into a small set containing high value (or low cost) solutions to be examined more closely and a larger set of their opposites (those to be ignored). While desirable, efficient divisions are often difficult to achieve in practice and so the creation of an effective algorithm is highly dependent upon the nature of the problem to be solved and the skill of the analyst creating the algorithm.

The core of the approach is a simple observation that (for a minimization task) if the lower bound for a subregion $A$ from the search tree is greater than the upper bound for any other (previously examined) subregion $B$ , then $A$ may be safely discarded from the search. This step is called pruning. It is usually implemented by maintaining a global variable $m$ that records the minimum upper bound seen among all subregions examined so far; any node whose lower bound is greater than $m$ can be discarded.

It may happen that the upper bound for a node matches its lower bound; that value is then the minimum of the function within the corresponding subregion. Sometimes there is a direct way of finding such a minimum. In both these cases it is said that the node is solved. Note that this node may still be pruned as the algorithm progresses.

Ideally the procedure stops when all nodes of the search tree are either pruned or solved. At that point, all non-pruned subregions will have their upper and lower bounds equal to the global minimum of the function. In practice the procedure is often terminated after a given time; at that point, the minimum lower bound and the maximum upper bound, among all non-pruned sections, define a range of values that contains the global minimum. Alternatively, within an overriding time constraint, the algorithm may be terminatated when some error criterion such as (max-min)/(min + max) falls below a specified value.

The efficiency of the method depends critically on the effectiveness of the branching and bounding algorithms used; bad choices could lead to repeated branching, without any pruning, until the sub-regions become very small. In that case the method would be reduced to an exhaustive enumeration of the domain, which is often impractically large. There is no universal bounding algorithm that works for all problems, and there is little hope that one will ever be found; therefore the general paradigm needs to be implemented separately for each application, with branching and bounding algorithms that are specially designed for it.

Branch and bound methods may be classified according to the bounding methods and according to the ways of creating/inspecting the search tree nodes.

This method naturally lends itself for parallel and distributed implementations, see, e.g., the traveling salesman problem article.

[edit] Applications

This approach is used for a number of NP-hard problems, such as

Knapsack problem
Integer programming
Nonlinear programming (see this for non-convex programming)
Traveling salesman problem (TSP)
Quadratic assignment problem (QAP)
Maximum satisfiability problem (MAX-SAT)

It may also be a base of various heuristics. For example, one may wish to stop branching when the gap between the upper and lower bounds becomes smaller than a certain threshold. This is used when the solution is "good enough for practical purposes" and can greatly reduce the computations required. This type of solution is particularly applicable when the cost function used is noisy or is the result of statistical estimates and so is not known precisely but rather only known to lie within a range of values with a specific probability.