Branch and bound (original) (raw)

From Wikipedia, the free encyclopedia

Optimization by removing non-optimal solutions to subproblems

Branch-and-bound (BB, B&B, or BnB) is a method for solving optimization problems by breaking them down into smaller subproblems and using a bounding function to eliminate subproblems 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 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, then 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 NP-hard 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 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:

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:

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 to 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.

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 problem-specific branching rule. As such, the generic algorithm presented here is a higher-order function.

  1. Using a heuristic, find a solution xh to the optimization problem. Store its value, B = f(xh). (If no heuristic is available, set B to infinity.) B will denote the best solution found so far, and will be used as an upper bound on candidate solutions.
  2. Initialize a queue to hold a partial solution with none of the variables of the problem assigned.
  3. Loop until the queue is empty:
    1. Take a node N off the queue.
    2. If N represents a single candidate solution x and f(x) < B, then x is the best solution so far. Record it and set B ← f(x).
    3. Else, branch on N to produce new nodes Ni. For each of these:
      1. If bound(Ni) > B, do nothing; since the lower bound on this node is greater than the upper bound of the problem, it will never lead to the optimal solution, and can be discarded.
      2. Else, store Ni on the queue.

Several different queue data structures can be used. This FIFO-queue-based implementation yields a breadth-first search. A stack (LIFO queue) will yield a depth-first algorithm. A best-first branch-and-bound algorithm can be obtained by using a priority queue that sorts nodes on their lower bounds.[3]

Examples of best-first search algorithms with this premise are Dijkstra's algorithm and its descendant A* search. The depth-first 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::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 candidate_queue; // problem-specific 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, and other types of callable objects in the C++ programming language.

When x {\displaystyle \mathbf {x} } {\displaystyle \mathbf {x} } is a vector of R n {\displaystyle \mathbb {R} ^{n}} {\displaystyle \mathbb {R} ^{n}}, branch-and-bound algorithms can be combined with interval analysis[8] and contractor techniques to provide guaranteed enclosures of the global minimum.[9][10]

This approach is used for a number of NP-hard problems:

Branch-and-bound 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_]

Relation to other algorithms

[edit]

Nau et al. present a generalization of branch and bound that also subsumes the A*, B* and alpha-beta search algorithms.[16]

Optimization example

[edit]

Branch-and-bound can be used maximize Z = 5 x 1 + 6 x 2 {\displaystyle Z=5x_{1}+6x_{2}} {\displaystyle Z=5x_{1}+6x_{2}} with the constraints

x 1 + x 2 ≤ 50 {\displaystyle x_{1}+x_{2}\leq 50} {\displaystyle x_{1}+x_{2}\leq 50}

4 x 1 + 7 x 2 ≤ 280 {\displaystyle 4x_{1}+7x_{2}\leq 280} {\displaystyle 4x_{1}+7x_{2}\leq 280}

x 1 , x 2 ≥ 0 {\displaystyle x_{1},x_{2}\geq 0} {\displaystyle x_{1},x_{2}\geq 0}

x 1 {\displaystyle x_{1}} {\displaystyle x_{1}} and x 2 {\displaystyle x_{2}} {\displaystyle x_{2}} are integers.

The first step is to relax the integer constraint. We have two extreme points for the first equation that form a line: [ x 1 x 2 ] = [ 50 0 ] {\displaystyle {\begin{bmatrix}x_{1}\\x_{2}\end{bmatrix}}={\begin{bmatrix}50\\0\end{bmatrix}}} {\displaystyle {\begin{bmatrix}x_{1}\\x_{2}\end{bmatrix}}={\begin{bmatrix}50\\0\end{bmatrix}}} and [ 0 50 ] {\displaystyle {\begin{bmatrix}0\\50\end{bmatrix}}} {\displaystyle {\begin{bmatrix}0\\50\end{bmatrix}}}. We can form the second line with the vector points [ 0 40 ] {\displaystyle {\begin{bmatrix}0\\40\end{bmatrix}}} {\displaystyle {\begin{bmatrix}0\\40\end{bmatrix}}} and [ 70 0 ] {\displaystyle {\begin{bmatrix}70\\0\end{bmatrix}}} {\displaystyle {\begin{bmatrix}70\\0\end{bmatrix}}}.

the two lines.

The third point is [ 0 0 ] {\displaystyle {\begin{bmatrix}0\\0\end{bmatrix}}} {\displaystyle {\begin{bmatrix}0\\0\end{bmatrix}}}. This is a convex hull region, so the solution lies on one of the vertices of the region. We can find the intersection using row reduction, which is [ 70 / 3 80 / 3 ] {\displaystyle {\begin{bmatrix}70/3\\80/3\end{bmatrix}}} {\displaystyle {\begin{bmatrix}70/3\\80/3\end{bmatrix}}} with a value of 276 + 2/3. We test the other endpoints by sweeping the line over the region and find this is the maximum over the reals.

We choose the variable with the maximum fractional part, in this case x 2 {\displaystyle x_{2}} {\displaystyle x_{2}} becomes the parameter for the branch and bound method. We branch to x 2 ≤ 26 {\displaystyle x_{2}\leq 26} {\displaystyle x_{2}\leq 26} and obtain 276 at ⟨ 24 , 26 ⟩ {\displaystyle \langle 24,26\rangle } {\displaystyle \langle 24,26\rangle }. We have reached an integer solution so we move to the other branch x 2 ≥ 27 {\displaystyle x_{2}\geq 27} {\displaystyle x_{2}\geq 27}. We obtain 275.75 at ⟨ 22.75 , 27 ⟩ {\displaystyle \langle 22.75,27\rangle } {\displaystyle \langle 22.75,27\rangle }. We have a decimal, so we branch x 1 {\displaystyle x_{1}} {\displaystyle x_{1}} to x 1 ≤ 22 {\displaystyle x_{1}\leq 22} {\displaystyle x_{1}\leq 22} and we find 274.571 at ⟨ 22 , 27.4286 ⟩ {\displaystyle \langle 22,27.4286\rangle } {\displaystyle \langle 22,27.4286\rangle }. We try the other branch x 1 ≥ 23 {\displaystyle x_{1}\geq 23} {\displaystyle x_{1}\geq 23} and there are no feasible solutions. Therefore, the maximum is 276 with x 1 = 24 {\displaystyle x_{1}=24} {\displaystyle x_{1}=24} and x 2 = 26 {\displaystyle x_{2}=26} {\displaystyle x_{2}=26}.

  1. ^ A. H. Land and A. G. Doig (1960). "An automatic method of solving discrete programming problems". Econometrica. 28 (3): 497–520. doi:10.2307/1910129. JSTOR 1910129.
  2. ^ "Staff News". www.lse.ac.uk. Archived from the original on 2021-02-24. Retrieved 2018-10-08.
  3. ^ a b c Clausen, Jens (1999). Branch and Bound Algorithms—Principles and Examples (PDF) (Technical report). University of Copenhagen. Archived from the original (PDF) on 2015-09-23. Retrieved 2014-08-13.
  4. ^ a b Little, John D. C.; Murty, Katta G.; Sweeney, Dura W.; Karel, Caroline (1963). "An algorithm for the traveling salesman problem" (PDF). Operations Research. 11 (6): 972–989. doi:10.1287/opre.11.6.972. hdl:1721.1/46828.
  5. ^ Balas, Egon; Toth, Paolo (1983). Branch and bound methods for the traveling salesman problem (PDF) (Report). Carnegie Mellon University Graduate School of Industrial Administration. Archived (PDF) from the original on October 20, 2012.
  6. ^ a b Bader, David A.; Hart, William E.; Phillips, Cynthia A. (2004). "Parallel Algorithm Design for Branch and Bound" (PDF). In Greenberg, H. J. (ed.). Tutorials on Emerging Methodologies and Applications in Operations Research. Kluwer Academic Press. Archived from the original (PDF) on 2017-08-13. Retrieved 2015-09-16.
  7. ^ Mehlhorn, Kurt; Sanders, Peter (2008). Algorithms and Data Structures: The Basic Toolbox (PDF). Springer. p. 249.
  8. ^ Moore, R. E. (1966). Interval Analysis. Englewood Cliff, New Jersey: Prentice-Hall. ISBN 0-13-476853-1.
  9. ^ Jaulin, L.; Kieffer, M.; Didrit, O.; Walter, E. (2001). Applied Interval Analysis. Berlin: Springer. ISBN 1-85233-219-0.
  10. ^ Hansen, E.R. (1992). Global Optimization using Interval Analysis. New York: Marcel Dekker.
  11. ^ Conway, Richard Walter; Maxwell, William L.; Miller, Louis W. (2003). Theory of Scheduling. Courier Dover Publications. pp. 56–61. ISBN 978-0-486-42817-8.
  12. ^ Fukunaga, Keinosuke; Narendra, Patrenahalli M. (1975). "A branch and bound algorithm for computing k-nearest neighbors". IEEE Transactions on Computers (7): 750–753. doi:10.1109/t-c.1975.224297. S2CID 5941649.
  13. ^ Narendra, Patrenahalli M.; Fukunaga, K. (1977). "A branch and bound algorithm for feature subset selection" (PDF). IEEE Transactions on Computers. C-26 (9): 917–922. doi:10.1109/TC.1977.1674939. S2CID 26204315.
  14. ^ Hazimeh, Hussein; Mazumder, Rahul; Saab, Ali (2020). "Sparse Regression at Scale: Branch-and-Bound rooted in First-Order Optimization". arXiv:2004.06152 [stat.CO].
  15. ^ Nowozin, Sebastian; Lampert, Christoph H. (2011). "Structured Learning and Prediction in Computer Vision". Foundations and Trends in Computer Graphics and Vision. 6 (3–4): 185–365. CiteSeerX 10.1.1.636.2651. doi:10.1561/0600000033. ISBN 978-1-60198-457-9.
  16. ^ Nau, Dana S.; Kumar, Vipin; Kanal, Laveen (1984). "General branch and bound, and its relation to A∗ and AO∗" (PDF). Artificial Intelligence. 23 (1): 29–58. doi:10.1016/0004-3702(84)90004-3.