Graph and tree search algorithms 


Listings 

Related topics 

Branch and bound (BB, B&B, or BnB) is an algorithm design paradigm for discrete and combinatorial optimization problems, as well as mathematical optimization. A branchandbound algorithm consists of a systematic enumeration of candidate solutions by means of 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,^{[1]}^{[2]} and has become the most commonly used tool for solving NPhard optimization problems.^{[3]} The name "branch and bound" first occurred in the work of Little et al. on the traveling salesman problem.^{[4]}^{[5]}
The goal of a branchandbound algorithm is to find a value x that maximizes or minimizes the value of a realvalued 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:
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 S_{I}. The instance representation has to come with three operations:
Using these operations, a B&B algorithm performs a topdown recursive search through the tree of instances formed by the branch operation. Upon visiting an instance I, it checks whether bound(I) is greater than an upper bound found so far; 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.
The following is the skeleton of a generic branch and bound algorithm for minimizing an arbitrary objective function f.^{[3]} To obtain an actual algorithm from this, one requires a bounding function bound, that computes lower bounds of f on nodes of the search tree, as well as a problemspecific branching rule. As such, the generic algorithm presented here is a higher order function.
Several different queue data structures can be used. This FIFO queuebased implementation yields a breadthfirst search. A stack (LIFO queue) will yield a depthfirst algorithm. A bestfirst branch and bound algorithm can be obtained by using a priority queue that sorts nodes on their lower bound.^{[3]} Examples of bestfirst search algorithms with this premise are Dijkstra's algorithm and its descendant A* search. The depthfirst variant is recommended when no good heuristic is available for producing an initial solution, because it quickly produces full solutions, and therefore upper bounds.^{[7]}
A C++like pseudocode implementation of the above is:
// C++like implementation of branch and bound,
// assuming the objective function f is to be minimized
CombinatorialSolution branch_and_bound_solve(
CombinatorialProblem problem,
ObjectiveFunction objective_function /*f*/,
BoundingFunction lower_bound_function /*bound*/)
{
// Step 1 above
double problem_upper_bound = std::numeric_limits<double>::infinity; // = B
CombinatorialSolution heuristic_solution = heuristic_solve(problem); // x_h
problem_upper_bound = objective_function(heuristic_solution); // B = f(x_h)
CombinatorialSolution current_optimum = heuristic_solution;
// Step 2 above
queue<CandidateSolutionTree> candidate_queue;
// problemspecific queue initialization
candidate_queue = populate_candidates(problem);
while (!candidate_queue.empty()) { // Step 3 above
// Step 3.1
CandidateSolutionTree node = candidate_queue.pop();
// "node" represents N above
if (node.represents_single_candidate()) { // Step 3.2
if (objective_function(node.candidate()) < problem_upper_bound) {
current_optimum = node.candidate();
problem_upper_bound = objective_function(current_optimum);
}
// else, node is a single candidate which is not optimum
}
else { // Step 3.3: node represents a branch of candidate solutions
// "child_branch" represents N_i above
for (auto&& child_branch : node.candidate_nodes) {
if (lower_bound_function(child_branch) <= problem_upper_bound) {
candidate_queue.enqueue(child_branch); // Step 3.3.2
}
// otherwise, bound(N_i) > B so we prune the branch; step 3.3.1
}
}
}
return current_optimum;
}
In the above pseudocode, the functions heuristic_solve
and populate_candidates
called as subroutines must be provided as applicable to the problem. The functions f (objective_function
) and bound (lower_bound_function
) are treated as function objects as written, and could correspond to lambda expressions, function pointers or functors in the C++ programming language, among other types of callable objects.
When is a vector of , branch and bound algorithms can be combined with interval analysis^{[8]} and contractor techniques in order to provide guaranteed enclosures of the global minimum.^{[9]}^{[10]}
This approach is used for a number of NPhard problems:
Branchandbound 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.^{[citation needed]}
Nau et al. present a generalization of branch and bound that also subsumes the A*, B* and alphabeta search algorithms.^{[16]}
By: Wikipedia.org
Edited: 20210618 18:02:42
Source: Wikipedia.org