SEARCH

SEARCH BY CITATION

Keywords:

  • combinatorial optimization;
  • heuristics;
  • metaheuristics;
  • optimization

Abstract

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

This paper argues that many exact and heuristic methods have common structure that permits some degree of unification. It interprets solution algorithms as primal–dual methods in which the primal component searches over problem restrictions, and the dual component obtains bounds on the optimal value. In particular, the concept of an inference dual provides the basis for constraint-directed search, which is a feature of many exact and heuristic methods. The motivations for unification are (a) to encourage the exchange of algorithmic techniques between exact and heuristic methods and (b) to design solution methods that transition gracefully from exact to heuristic modes as problem instances scale up.

1. Introduction

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

Exact and heuristic methods for optimization are often regarded as belonging to entirely different categories. Exact methods generally take the form of branching and other forms of exhaustive search, while heuristic methods have a very different character, perhaps local search or an imitation of a natural process, such as annealing or biological evolution.

This bifurcation of methods has several drawbacks. It discourages the cross-fertilization of algorithmic ideas developed for exact and heuristic methods. It requires switching to a different solution algorithm when problem instances become too large to solve exactly. Ideally, a single solution method would transition gracefully from exhaustive to inexhaustive search as the problem scales up. Finally, it draws attention away from the underlying unity of exact and heuristic methods.

This paper makes a case that there is, in fact, a fair amount of common structure in exact and heuristic methods. Most algorithms of either type are special cases of a primal–dual solution strategy, although particular algorithms may lack some elements of the strategy. The primal component of the strategy enumerates problem restrictions in search of a good solution, while the dual component seeks a proof that bounds the optimal value, with the eventual aim of proving the optimality of a solution found by primal search. The dual can be an inference dual or relaxation dual.

Recognizing this commonality has at least three benefits. One is that the structural similarity of exact and heuristic methods may suggest algorithms that can be run in either an exact or heuristic mode. A second benefit is cross-fertilization of algorithmic ideas. When heuristic methods are viewed as having a primal–dual structure, it may become evident how to adapt the inference and relaxation techniques of exact methods to a heuristic method. In particular, the dual perspective may yield a lower bound on the optimal value, which is normally unavailable in heuristic methods. Conversely, when the primal–dual structure of exact methods is recognized, one may see how to adapt the local search ideas of heuristic methods to exhaustive search. For example, tree search with strong branching, a well-known approach to mixed integer programing, can be interpreted as a local search algorithm for solving a dual problem. Local search techniques can then be adapted to obtain alternative branching strategies.

A third benefit is more effective exploitation of problem structure in heuristic methods. A primal–dual method simultaneously solves the primal problem and an inference dual, or the primal problem and a relaxation dual. But it is primarily through inference (e.g., constraint propagation and filtering) and relaxation (e.g., cutting planes) methods that exact methods take advantage of problem structure. By viewing a heuristic method as possessing these same elements, similar strategies for exploiting structure may become evident.

Duality is proposed as a unifying principle for exact optimization methods in Hooker (2006, 2012). In the present paper, this framework is extended to encompass heuristic methods. The structural similarity between some exact and heuristic methods is pointed out in Hooker (2005), in particular between branching and GRASP, as well as between Benders decomposition and tabu search. These ideas are incorporated here.

The paper begins with an introduction to inference and relaxation duality, followed by a description of primal–dual algorithmic structure. It then identifies this structure in a sampling of exact algorithms, including the simplex method, branch-and-bound methods, satisfiability solvers, and Benders decomposition. Following this, it finds the same structure in such heuristic methods as local search, tabu search, evolutionary algorithms, ant colony optimization, and particle swarm optimization. Along the way, attempts are made to indicate how algorithmic ideas can be exchanged between exact and heuristic methods, and where possible, how a single algorithm can be designed to transition from one to the other.

2. Fundamentals

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

An optimization problem may be written as

  • display math(1)

where f is the objective function and S the feasible set. Generally, x is a tuple inline image of variables. The “epigraph” of (1) is inline image. A “relaxation” of (1) is a problem

  • display math(2)

whose epigraph contains E. If the epigraph of (2) is a subset of E, then (2) is a “restriction” of (1).

2.1. Inference and relaxation duals

An “inference dual” (Hooker, 2000) seeks the tightest bound on the objective function that can be deduced from the constraint set, using a specified method of logical deduction. So an inference dual of (1) is

  • display math(3)

where inline image is a specified proof family. The notation inline image means that proof P deduces B from A. The inference dual clearly satisfies “weak duality,” meaning that inline image for any feasible x in the primal and any feasible inline image in the dual. “Strong duality” holds when the primal and dual have the same optimal value. By convention, the optimal value of a minimization problem is ∞ when it is infeasible and inline image when it is unbounded, and vice versa for a maximization problem.

As an example, suppose (1) is a linear programing (LP) problem

  • display math(4)

The inference dual is

  • display math(5)

The classical LP dual is obtained when inline image is defined as follows. Let a “surrogate” of inline image be a non-negative linear combination inline image. Then u can be regarded as encoding a proof of inline image when inline image dominates inline image; that is, when inline image and inline image, or no inline image satisfies inline image. If inline image consists of all inline image, the inference dual (5) becomes

  • display math

for a feasible LP. This is equivalent to inline image, which is the classical LP dual. Inference LP duality is strong, while classical LP duality is strong under a constraint qualification (i.e., the primal or classical dual is feasible).

It is shown in Hooker (2007a) that the Lagrangean dual, surrogate dual, and subadditive dual are inference duals for appropriate definitions of inline image. Additional inference duals are defined below in the context of algorithms in which they play a central role.

A “relaxation” dual is defined over a family of parameterized relaxations. It seeks the relaxation whose optimal value provides the tightest possible lower bound on the optimal value of the original problem. So a relaxation dual of (1) can be written as

  • display math(6)

where

  • display math(7)

Problem (7) is a relaxation of (1) parameterized by inline image, which means that for any inline image, inline image and inline image for all inline image. The relaxation dual satisfies weak duality because inline image is the minimum value of some relaxation of (1) and is therefore a lower bound on inline image for any inline image.

The classical LP dual is a relaxation dual as well as an inference dual for a feasible LP. We let the parameterized relaxation minimize inline image over a surrogate of inline image. The resulting dual is inline image, where

  • display math

The Farkas Lemma implies that the relaxation dual is equivalent to the classical LP dual if the LP is feasible. The Lagrangean, surrogate, and subadditive duals are likewise relaxation duals.

2.2. The algorithmic framework

A general algorithm for combinatorial optimization solves the primal problem by enumerating restrictions of the primal problem. Branching methods, for example, create restrictions by branching on variables. Each node of the search tree corresponds to a restriction of the original problem. The motivation for creating restrictions is that they may be easier to solve than the original problem. If the enumeration is exhaustive, the smallest optimal value of a restriction is the optimal value of the original problem.

Heuristic methods often enumerate restrictions by local search; that is, by examining neighborhoods defined around a sequence of solutions. The neighborhood is the feasible set of a restriction and should be small enough to search easily. The restriction is solved by selecting an attractive solution in the neighborhood to serve as the center of the next neighborhood. Local search is, of course, rarely exhaustive.

A “primal–dual” algorithm seeks lower bounds on the optimal value while enumerating restrictions. It obtains bounds by (partially) solving an inference dual or a relaxation dual. A lower bound can reduce enumeration, because one may wish to terminate the algorithm after finding a restriction whose optimal value is close to the lower bound.

A key issue is how restrictive the restrictions should be. Tighter restrictions fix more variables and have smaller feasible sets. They may be easier to solve, but there are many to enumerate, and most have poor solutions. Looser restrictions have larger feasible sets and therefore better optimal values, but they may be hard to solve. One general strategy is to tighten the restrictions until they become easy to solve. This occurs in branching methods that branch until the problems at leaf nodes can be solved. The opposite strategy is to enlarge the feasible set until the solution quality improves, but not so much that the restrictions become intractable, as is commonly done in large neighborhood search methods. In some cases, the fixed variables are selected in advance, as in Benders decomposition.

An important feature of primal–dual methods is the use of inference and relaxation to guide the search over restrictions, as well as to obtain bounds. The inference dual provides the basis for “constraint-directed search,” a very broad class of search methods that include branching, Benders decomposition, dynamic backtracking, and tabu search. Suppose that an algorithm enumerates restrictions by fixing a tuple inline image of variables in x to inline image in each iteration k. So inline image, where inline image is the tuple of variables in x that are not fixed. This defines a subproblem of (1):

  • display math(8)

The inference dual of (8) is

  • display math(9)

If inline image is an optimal solution of (9), then inline image deduces the lower bound inline image when inline image is fixed to inline image. This same proof inline image may deduce a useful bound LBinline image for general inline image, where in particular LBinline image. This means that if a future iteration fixes the variables in inline image, the resulting optimal value (after solving the subproblem) cannot be better than the LBinline image. The next partial solution inline image cannot result in a value better than

  • display math(10)

where inline image means that all the variables in tuple inline image occur in tuple inline image. There is no need to consider a value of inline image for which the bound in (10) is no better than the best value found so far. This is the principle behind Benders decomposition, for example.

An important special case occurs when the subproblem (8) is a feasibility problem with no objective function. In this case, the solution inline image of the inference dual is a proof of infeasibility. This same proof may deduce infeasibility for values of inline image other than inline image. The bound LBinline image therefore becomes a “nogood constraint” inline image, which is violated by any value of inline image for which inline image proves infeasibility in the subproblem. In particular, inline image violates inline image. The next partial solution inline image cannot result in a feasible subproblem unless it satisfies the constraints in

  • display math

This is the principle behind dynamic backtracking, clause learning in satisfiability algorithms, and tabu search. It is convenient to refer to a bound LBinline image as a “nogood bound.”

Relaxation, as well as inference, can also guide the search over problem restrictions. Typically, a relaxation (or relaxation dual) of the current restriction is solved when the restriction itself is too hard to solve. This is done at the nodes of a branch-and-bound tree, for example. If the solution of the relaxation is feasible for the restriction, then the restriction itself is solved. Otherwise, the solution may provide a clue as to how the restriction should be tightened to obtain an easier problem. For example, if an LP relaxation of an integer programing problem is solved, the search can branch on variables that take a fractional value in the solution of the relaxation.

3. Exact methods

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

3.1. Simplex method

The simplex method for an LP problem (4) enumerates problem restrictions while solving the LP dual of each restriction to obtain a bound. It can be interpreted as a local search as well as constraint-directed search.

In each iteration of the simplex method, the variables x are partitioned into basic and nonbasic variables, inline image, with a corresponding partition inline image of the coefficient matrix. A restriction is created by fixing inline image, where inline image consists of all the nonbasic variables except a variable inline image that will enter the basis. It minimizes inline image subject to the requirement that x lie on an edge of the feasible polyhedron:

  • display math(11)

where inline image is column j of A. The feasible set of (11) can be regarded as a neighborhood of the current solution inline image, and the simplex method can therefore be seen as a local search method (Fig. 1). The restriction (11) is solved by moving to the opposite end of the edge, so that

  • display math

where inline image is the minimizing value of i.

image

Figure 1. Simplex method as local search.

Download figure to PowerPoint

The dual analysis is somewhat different from the textbook version but allows the simplex method to be interpreted as constraint-directed search. We first write the subproblem (11) as

  • math image(12)

by inserting the nonbasic variables inline image and fixing them to a constant inline image that is currently zero. The LP dual of (12) is

  • display math(13)

Because the first constraint is tight for inline image, the dual solution u satisfies inline image for inline image and inline image. Due to weak duality, the dual solution yields a valid nogood bound

  • display math

even when inline image is not fixed to zero. So when we define the next neighborhood by selecting a variable inline image to release from zero, we cannot improve on the current solution value inline image unless

  • display math

Because inline image, it suffices that inline image; that is, the reduced cost is negative. We therefore select an inline image with negative reduced cost. It is in this manner that the inference dual of the restricted problem guides the simplex method.

3.2. Branch and bound as constraint-directed search

Like the simplex method, branch-and-bound methods for discrete optimization are local search methods that use constraint-directed search. Unlike the simplex method, the local search mechanism solves a relaxation dual. Both interpretations can lead to significant improvements in the classical branch-and-bound algorithm.

We first develop the constraint-directed search perspective. To simplify discussion, suppose for the moment that we seek only a feasible solution. At each node of the search tree, we branch on a variable inline image by creating a child node for each possible value of inline image. A node on level k is reached by setting inline image to some set of values inline image, which defines a restriction of the original problem. The tree search can be interpreted as enumerating problem restrictions that correspond to the leaf nodes.

To view the search as constraint-directed, suppose we find that a leaf node subproblem is infeasible, perhaps by trying to solve its LP relaxation. At this point, we backtrack. An alternate interpretation of backtracking is that we create a nogood constraint inline image. We then generate the next node of the tree by assigning values to variables inline image that satisfy all the nogood constraints created so far, continuing until the subproblem is solved or proved infeasible. The nogood constraints ensure that we do not examine the same leaf node twice. If the subproblem is solved, we are done. Otherwise, we continue generating leaf nodes in this fashion until no assignment satisfies all of the nogood constraints, at which point the search is exhaustive. Any search tree can be built in this way.

So far, the inference dual does not play a role in the creation of nogood constraints. We may be able to strengthen the nogoods, however, by examining the proof of infeasibility that solves the inference dual of the subproblem or its relaxation. We may find, for example, that only some of the variable settings appear as premises of the proof, perhaps inline image. Then we can create a strengthened nogood constraint inline image. This may allow us to skip an entire section of the branching tree. This is known as “backjumping,” a special case of “dynamic backtracking” (Ginsberg, 1993; Ginsberg and McAllester, 1994; McAllester, 1993). It is the basis for clause learning in satisfiability algorithms, discussed in section 'Clause learning for satisfiability solvers'.

Constraint-directed search can be specialized to integer programing (Hooker, 2000), where it is sometimes referred to as “conflict analysis.” Suppose we wish to solve the problem

  • display math(14)

The LP relaxation of the subproblem at a given leaf node is

  • display math(15)

where p and q are lower and upper bounds imposed by branching (Fig. 2). If inline image, the variable inline image has been fixed. We associate dual variables inline image with the three constraints in (15). If the subproblem relaxation (15) is infeasible, its LP dual is solved by a tuple inline image that proves infeasibility because inline image and inline image. This can guide future branching. If p and q are, respectively, the lower and upper branching bounds at a subsequent node of the tree, the subproblem at that node can be feasible only if

  • display math(16)

This can be treated as a nogood constraint. Suppose we wish to branch on a variable inline image with a fractional value inline image in the solution of (15). A left branch defined by inline image is feasible only if setting inline image satisfies (16), which is to say

  • display math(17)

So the left branch can be eliminated if this inequality is violated, and analogously for the right branch. This test can be performed repeatedly at a given node by substituting into (17) the dual solution inline image obtained at each infeasible leaf node encountered so far. The idea can be extended to feasible leaf nodes and strengthened in various ways (Hooker, 2012).

image

Figure 2. Conflict analysis in a branch-and-bound search.

Download figure to PowerPoint

This type of bounding enables backjumping in an integer programing search tree. Although backjumping is an old idea (Gaschnig, 1978; Stallman and Sussman, 1977), constraint-directed branching has only recently been implemented in an integer programing solver (Achterberg, 2007; Sandholm and Shields, 2006).

3.3. Branch and bound as dual local search

The generation of a branch-and-bound tree can be regarded as a local search algorithm for solving a relaxation dual. This opens the possibility of applying local search ideas to define branching strategies. It also suggests how a branch-and-bound method can gracefully transition to a heuristic method.

Any complete or incomplete search tree T yields a lower bound inline image on the optimal value of the original problem. The bound inline image is the minimum of inline image over all leaf nodes and incomplete nodes i, where inline image is the optimal value of the relaxation at node i. An incomplete node is a nonleaf node at which at least one child is missing from T. The minimum can be taken only over leaf nodes and incomplete nodes that do not descend from another incomplete node. For example, Fig. 3 shows a search tree in which only the solid portion has been explored. It proves the bound inline image.

image

Figure 3. Calculation of bound in incomplete branch-and-bound tree (dashed portion is unexplored).

Download figure to PowerPoint

The tree variable T can be viewed as parameterizing a family of relaxations with optimal value inline image. The problem of finding the best possible bound is the relaxation dual inline image, where T ranges over all complete and incomplete search trees. There is no duality gap if the relaxation dual is solved to optimality, because inline image is the optimal value of the original problem for any complete tree T.

Branching trees are built by adding one child node at a time. This in effect defines a neighborhood of each incomplete tree T that consists of trees obtained by adding one child node to some node of T. The choice of which node to add is therefore a choice of which element of the neighborhood to select. Because adding a node never results in a weaker bound, local search in this context always results in monotone nondecreasing bounds. In a discrete optimization problem, a local search converges finitely to the best possible bound. For example, adding any of the unexplored nodes in Fig. 3 creates a neighboring tree.

One well-known strategy for node selection is strong branching (Bixby et al., 1995), which adds to T the node at which the relaxation provides the largest bound. (The relaxation value may be estimated by using pseudocosts [Benichou et al., 1971; Gautier and Ribiere, 1977].) This is in effect a strategy for selecting a tree in the neighborhood of T. There are, however, other ways to design a local search, which result in different and perhaps novel node selection rules. For example, one can use uphill search by selecting the neighboring tree inline image that maximizes inline image. This corresponds to none of the traditional node selection rules, including strong branching, depth-first search, breadth-first search, iterative deepening, and limited discrepancy search.

Uphill search can be used in Fig. 3. Adding node 5 proves the bound inline image as shown in Fig. 4, which is an improvement. Adding node 10 replaces inline image with two tighter bounds as in Fig. 5, but the overall minimum of 4 does not improve. Enumeration of all neighboring trees reveals that the tree of Fig. 4 yields the greatest improvement in the bound.

image

Figure 4. Recalculation of bound after adding node 5.

Download figure to PowerPoint

image

Figure 5. Recalculation of bound after adding node 10.

Download figure to PowerPoint

One could also use “simulated annealing” (Kirkpatrick et al., 1983) in this context. This is a local search algorithm in which a tree inline image is randomly selected from the neighborhood N of T. If inline image, tree inline image is accepted, and the process repeats in a neighborhood inline image of inline image. If inline image, then inline image is nonetheless accepted with probability p, and the process repeats in neighborhood inline image. If inline image is rejected, another tree inline image is randomly selected from N. The probability p may decrease according to a “cooling schedule” that mimics an annealing process toward a minimum-energy state in materials. A simulated annealing approach relieves the computational burden of evaluating inline image for all neighboring trees inline image; that is, computing the relaxation value at all nodes that could be added to T. It may examine a larger number of trees, however, before a suitable lower bound is obtained.

A tree-building strategy designed to solve the relaxation dual is not necessarily a good strategy for finding feasible solutions. For example, an uphill search tends to add shallow nodes to the tree, which are not likely to yield feasible solutions. However, this is a fundamental difficulty of using the same tree search to find feasible solutions and prove optimality; that is, using the same tree search to solve the primal and relaxation duals. One escape from this dilemma is to use a primal heuristic that finds feasible solutions in parallel with a branching tree that finds bounds. Primal heuristics have in fact become a standard feature of branch-and-bound solvers.

The use of a primal heuristic allows one to design a local search method that is best suited for the relaxation dual. By running the two heuristics in parallel, the optimal value can be bracketed by increasingly tight upper bounds from the primal heuristic and lower bounds from the dual heuristic. The dual heuristic can also contribute upper bounds when the solution of the relaxation at a leaf node is integral. An exact solution is obtained when the tightest upper and lower bounds coincide, which in the worst case will occur when the dual heuristic runs to completion. One could also design a primal algorithm that becomes exhaustive search if it runs long enough, such as iterative deepening or limited discrepancy search. The branch-and-bound mechanism becomes a heuristic method simply by terminating the primal and dual algorithms when acceptably tight bounds are obtained.

3.4. Clause learning for satisfiability solvers

Clause learning is essential to the success of state-of-the-art satisfiability solvers (Beame et al., 2003; Gomes, 2008; Moskewicz et al., 2001). It is a straightforward case of constraint-directed search that relies on the inference dual.

The satisfiability problem seeks a feasible solution for a set of logical clauses. A clause is a disjunction of literals, each of which has the form inline image or inline image, where inline image is a Boolean variable and ¬ is negation. So a clause has the form

  • display math

Most state-of-the-art solvers use some variant of the Davis-Putnam-Loveland-Logemann (DPLL) algorithm (Davis, 1962; Davis and Putnam, 1960), which is a simple branching scheme. The algorithm branches at each nonleaf node by setting some variable inline image to true and to false, which adds the unit clause inline image or inline image to the clause set at the child nodes. To simplify exposition, we suppose that the subproblem at each node contains all the original clauses and all unit clauses added by branching.

Before branching at each node, “unit resolution” is applied to the clause set at that node. Unit resolution is an inference method that operates by removing unit clauses. Thus, if the clause set contains a unit clause consisting of the literal inline image, it concludes that inline image must be true, deletes all clauses that contain inline image (because they are satisfied), and deletes the literal inline image wherever it occurs (because it cannot be true). A unit clause inline image is treated analogously. The process continues until no unit clauses remain. If unit resolution generates the empty clause, the clause set is unsatisfiable, and the search backtracks. If no clauses remain after unit resolution, the clause set is satisfied, and the search terminates. If neither occurs, the search branches on a variable that remains in the clause set.

If the subproblem at a node is unsatisfiable, the unit resolution proof of the empty clause solves an inference dual, namely, the inference dual in which the inference method is unit resolution. We can formulate a nogood constraint by identifying the branching-induced unit clauses that serve as premises in the proof. For example, Fig. 6 shows a branching tree for the satisfiability problem below:

  • display math

Fixing inline image yields a unit resolution proof of infeasibility in which inline image and inline image serve as premises. We therefore generate the nogood constraint inline image, which in this context is known as a “conflict clause.” Backtracking, we fix inline image and obtain the conflict clause inline image, which combines with the first conflict clause to obtain the resolvent inline image. We must now backjump to level 2 of the tree to satisfy this conflict clause, which accelerates the search. Setting inline image already creates infeasibility and the conflict clause inline image, which resolves with inline image to yield x1. Only one more solution inline image is possible, which creates infeasibility and the conflict clause inline image. This resolves with x1 to obtain the empty clause, which means that no more solutions satisfy the conflict clauses, and the search is complete. In practice, conflict clauses are rapidly identified by finding certain types of cuts in an “implication graph” (Gomes, 2008), but this process corresponds to constructing a unit resolution proof of infeasibility.

image

Figure 6. DPLL search tree with backjumping.

Download figure to PowerPoint

Note that next leaf node can always be generated by assigning values to variables so as to satisfy the conflict clauses so far generated, until unit resolution detects infeasibility or satisfaction. In fact, the branching framework can be dropped altogether, and the algorithm can proceed purely as constraint-directed search. However, because the conflict clauses are clauses, they can simply be added to the constraint set, which allows unit resolution to detect infeasibility sooner. Some solvers that operate along these lines may nonetheless abandon the search tree framework and proceed in a mode similar to pure constraint-directed search.

A DPLL algorithm with clause learning is a special case of dynamic backtracking. A slight generalization of this process results in partial-order dynamic backtracking (Bliek, 1998; McAllester, 1993), which is also a form of constraint-directed search. The main point here is that DPLL with clause learning has basically the same algorithmic structure as the simplex method, branch and bound with conflict analysis, and—as we see next—Benders decomposition.

3.5. Benders decomposition

Benders decomposition (Benders, 1962) is constraint-directed search in which the inference dual is the LP dual, and the nogood constraints are known as “Benders cuts.” It is distinguished by the fact that the subproblem is an LP and always contains the same variables. These variables are carefully chosen to define a subproblem that is easy to solve.

Once Benders decomposition is seen as a special case of constraint-directed search, one can substitute different kinds of inference duals for the LP dual and obtain Benders cuts for a wide variety of subproblems, not just LPs. The resulting method might be called “logic-based” Benders decomposition (Hooker, 2000; Hooker and Ottosson, 2003; Hooker and Yan, 1995), because Benders cuts are based on the logical form of the optimality proof that solves the dual. The method has been applied to a wide variety of problems, often with substantial improvement over the previous state of the art (surveyed in Hooker 2012). We will see in section 'Tabu search' that tabu search has a similar structure, and this may allow importation of Benders techniques into a local search framework.

Logic-based Benders decomposition begins with a partition of the variables inline image, where z is the tuple of variables that appear in the subproblem. The problem therefore has the form

  • display math(18)

Like branching, Benders decomposition conducts a search over problem restrictions, but it defines a restriction by always fixing the same variables y. If y is fixed to inline image, we have the subproblem

  • display math(19)

The inference dual is

  • display math(20)

If inline image is an optimal solution of (20) in iteration k, the proof inline image may deduce a bound LBinline image for general y. We therefore create the nogood bound (Benders cut) inline image and add it to the pool of nogood bounds from previous iterations. To select the next value of y, we minimize v subject to all the Benders cuts. That is, we solve the “master problem”

  • display math(21)

The solution inline image of the master problem defines the next subproblem. The algorithm terminates when the optimal value of the master problem equals inline image.

The classical Benders method is applied to a problem of the form

  • display math(22)

which has the subproblem

  • display math(23)

The LP dual of the subproblem is

  • display math

Assuming the subproblem (23) is feasible, the dual solution inline image in iteration k proves a nogood bound on v for any y:

  • display math

This is the classical Benders cut. When (23) is infeasible, the dual solution inline image proves infeasibility because inline image and inline image. So the next solution y can be feasible only if

  • display math

which becomes the Benders cut.

Algorithms having this same structure can solve a wide variety of problems. To use an example from Hooker (2007b), suppose that jobs inline image can be processed in any of shops inline image. We wish to assign jobs to shops, and schedule the jobs in each shop, so as to minimize makespan. Job j has processing time inline image in shop i, consumes resources at rate inline image, and has deadline inline image. Shop i has available resources inline image. Suppose, for example, if jobs 1, 2, and 3 are assigned to a shop 1 with maximum resources inline image, where the processing time and resource consumption of each job are illustrated in Fig. 7. The time windows inline image are given in Fig. 7. The minimum makespan schedule for this shop is shown in Fig. 7, with makespan 7. Similar schedules are computed for jobs assigned to other shops.

image

Figure 7. Cumulative scheduling subproblem for logic-based Benders decomposition.

Download figure to PowerPoint

To formulate the problem in general, let binary variable inline image if job j is assigned to shop i, and let inline image be the start time of job j. The problem is

  • math image

The first constraint defines the makespan M, and the second constraint enforces the deadlines. The cumulative constraint requires that jobs assigned to shop i be scheduled so that the total rate of resource consumption does not exceed inline image at any time. The notation inline image denotes the tuple of start times inline image for all jobs j that y assigns to shop i, and similarly for inline image and inline image.

The subproblem is not an LP, but logic-based Benders cuts can nonetheless be derived from the inference dual. For a fixed assignment inline image, the subproblem schedules the jobs to minimize makespan inline image in each shop i:

  • math image

In each iteration k, each subproblem i can be solved by, say, constraint programing to obtain the minimum makespan inline image for that shop. The proof of optimality solves the inference dual and provides the basis for several kinds of Benders cuts. At a minimum, one can observe the set inline image of jobs that play a role in the proof and write the logic-based Benders cut

  • display math(24)

for each i. If all jobs assigned to a shop have the same release time, the cut can be strengthened to

  • display math

The master problem is

  • display math

In the example of Fig. 7, the Benders cut for shop 1 is

  • display math

where inline image. Analysis of the optimality proof (inference dual) for shop 1 reveals that only jobs 2 and 3 play a role in the proof. We can therefore strengthen the cut by letting inline image.

This approach can reduce solution time by several orders of magnitude relative to mixed integer and constraint programing solvers (Hooker, 2007b; Yunes et al., 2010). It can be converted to a heuristic method simply by terminating it when the optimal value of the master problem is close to the best subproblem makespan obtained so far. Another option is to drop the oldest Benders cuts so that the number of cuts never exceeds a limit, much as is done in tabu search. The master problem therefore plays the role of a tabu list, as discussed in section 'Tabu search'.

4. Heuristic methods

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

4.1. Local search

Local search enumerates problem restrictions by examining neighborhoods of trial solutions. The neighborhood can be viewed as the feasible set of a restriction, which is solved by evaluating some or all of the solutions in the neighborhood. The next trial solution is selected on the basis of this evaluation, and a new neighborhood is defined for it.

Neighborhoods are typically defined by making small changes in the current solution, perhaps by swapping elements of the solution. More radical alterations are allowed in “very large neighborhood search” (Ahuja et al., 2002; Pisinger and Ropke, 2010), perhaps multiple swaps. In “variable-depth neighborhood search,” the size of the neighborhood is adjusted to that the subproblem is tractable but is general enough to have a good solution.

When neighborhoods are seen as problem restrictions, one can apply methods used in exact methods for creating problem restrictions. For example, one can fix some of the variables, and let the neighborhood represent the subproblem over the remaining variables. The size of the neighborhood can be adjusted by increasing the number of fixed variables until the subproblem becomes soluble, as is done in branching.

The idea can be illustrated with the traveling salesman problem (TSP). Let inline image be the city that immediately follows city i, and let inline image be the distance from city i to city j. The TSP can be written as

  • display math

where the circuit constraint requires that inline image describe a Hamiltonian cycle. We can define a neighborhood of the current solution inline image by fixing some of the variables inline image to inline image and solving for a minimum cost tour over inline image. A neighborhood of this sort is formed by reconnecting subchains. Suppose, for example, that inline image. This corresponds to the tour 1, 5, 2, 4, 3, 7, 6, 1, as illustrated in the upper left of Fig. 8. If we fix only inline image, the neighborhood consists of the five ways to reconnect the subchains 1 [RIGHTWARDS ARROW] 5, 2 [RIGHTWARDS ARROW] 4, 3 [RIGHTWARDS ARROW] 7, and 6.

image

Figure 8. The tour inline image (upper left) and five neighbors when inline image is fixed to (5, 4, 7).

Download figure to PowerPoint

This is quite different from the neighborhoods used in existing heuristics (Golden and Stewart, 1985; Pisinger and Ropke, 2010). Consider, for example, the well-known “2-opt” neighborhood, and suppose one starts with the solution inline image in an undirected graph, which corresponds to the tour inline image. A 2-opt neighborhood of inline image consists of the tours obtained by replacing any two edges inline image and inline image with inline image and inline image, respectively (an example appears in Fig. 9). This corresponds to replacing inline image with

  • display math

This is very different from fixing a subset of variables and allowing the rest to vary. The well-known Lin–Kernighan heuristic (Lin and Kernighan, 1973) essentially defines an r-opt neighborhood, where r is adjusted dynamically, but this again is very different from leaving a subset of variables unfixed, and similarly for other heuristics (surveyed in Pisinger and Ropke, 2010).

image

Figure 9. Obtaining one 2-opt neighbor of the tour on the left. There are 13 other neighbors.

Download figure to PowerPoint

Defining neighborhoods by partial variable assignments suggests a simple strategy for converting a local search heuristic to an exact algorithm. One can enumerate fixed values by creating a search tree, and carry the search to completion to obtain an exact solution.

The analogy with branching also suggests the use of relaxation bounding in heuristic search, an idea proposed in Prestwich (2004). One can solve a relaxation of the subproblem, and if the optimal value of the relaxation is no less than the best solution value found so far, the neighborhood can be rejected and replaced by another.

There is a good deal of research on the integration of heuristic methods and exact methods from constraint programing, surveyed in Blum et al. (2011) and Shaw (2011). Recent work includes Benchimol et al. (2010), Dhyani et al. (2010), El Hachemi et al. (2009), Khichane et al. (2010), Pham et al. (2010).

4.2. GRASP

We saw in the previous section that local search based on partial variable assignments can be viewed as an incomplete branching search. The same is true of a “greedy randomized adaptive search procedure” (GRASP; Feo et al., 1994, 1995), if it is generalized somewhat. This again allows for a relaxation bounding mechanism.

Each iteration of a conventional GRASP has a constructive phase followed by a local search phase. The constructive phase fixes the variables one at a time, based on greedy choices that are perturbed by a random element. After a complete solution is obtained by fixing all variables, a local search begins with this solution. The process is then repeated as desired.

The algorithm can be viewed as a randomized tree search that forgets much of where it has already searched. The constructive phase is a probe to the bottom of the search tree. Each step of the local search phase is a special case of a random backtrack to a higher node in the portion of the tree currently in memory. A pure local search might backtrack only one or two levels, depending on which variables are altered to obtain a neighboring solution. Once the search backtracks to a higher node, all successors of that node are erased to reduce memory requirements, although the value of the best feasible solution obtained so far is stored for bounding purposes. If a relaxation is available, one an use the same sort of bounding mechanism as in exhaustive branch-and-bound search. The result is that each iteration is an incomplete branch-and-bound method in which many nodes of the search tree evaporate soon after they are created.

A vehicle routing example from Hooker (2007a) illustrates the idea. A vehicle must begin at location A and deliver packages to four locations before returning to A. It may arrive as early as desired but must deliver the packages within the time windows shown in Table 1. Travel times inline image are also shown. The objective is to return home as soon as possible. Figure 10 shows an incomplete randomized search tree. The initial greedy probe selects each location with the earliest possible delivery, resulting in the tour ADCBEA with value 36. The search randomly backtracks to node 2, whereupon nodes 3 and 4 are deleted. The next customer E is randomly selected, and the next tour is continued in greedy fashion, this time without finding a feasible tour. The final random backtrack is to node 1.

Table 1. Data for a small vehicle routing problem with time windows
 Travel time to  
OriginBCDECustomerTime window
A5637B[20, 35]
B 854C[15, 25]
C  76D[10, 30]
D   5E[25, 35]
  
  
image

Figure 10. Incomplete search tree created by a generalized GRASP.

Download figure to PowerPoint

Bounding can be introduced by defining a relaxation at each node. A simple relaxation might observe that if a partial tour inline image has been defined, the travel time to an unvisited customer j from the previous customer will be at least inline image, where i ranges over all customers not in inline image. The travel time home from the last customer will be at least inline image, where j ranges over all customers not in inline image. Then if T is the earliest time the vehicle can depart customer k, the total time is at least

  • display math

This relaxation yields a bound of 40 at node 5, which allows the search to backtrack to node 2 before completing the greedy probe, as shown in Fig. 11. A bound of 38 at node 6 in Fig. 11 terminates the third probe as well, thus accelerating the search as in a branch-and-bound tree.

image

Figure 11. Incomplete search tree with relaxation bounding.

Download figure to PowerPoint

4.3. Tabu search

“Tabu search” (Glover, 1989; Hansen, 1986) is a constraint-directed form of local search. Viewing the method in this light suggests several ideas for modifying the search and connecting it with exact constraint-directed algorithms, such as Benders decomposition.

Standard tabu search evaluates all solutions in a neighborhood of the current solution inline image to find the best solution inline image that does not appear on the tabu list. A new neighborhood is defined about inline image, inline image is added to the tabu list, and the oldest element of the tabu list is removed. The function of the tabu list is to prevent the search from cycling through the same solutions. It is inspired by short-term memory in human searches, which prevents one from looking in a spot that was recently checked. When all goes well, a seeker with short-term memory keeps migrating to different parts of the search space, where there is little chance of drifting back to previous locations.

A long tabu list may exclude all solutions in the neighborhood, while a shorter one may fail to prevent cycling. This dilemma is often addressed by adding “medium-term” and “long-term” memory. A common medium-term device is to remember which elements of the solution were recently removed, so that they will not be re-inserted in the near future. For example, an edge that is removed from a TSP tour remains on the tabu list for several iterations, during which it will not be re-inserted. This in effect excludes solutions that are similar to a solution examined in the recent past and more effectively prevents cycling. Long-term memory might use a “diversification” strategy, which keeps track of solution values obtained over a long stretch of the search. If there has been no significant improvement, the search randomly jumps to a different part of the search space.

Tabu search is clearly an instance of constraint-directed search in which the tabu list contains nogood constraints. The search is inexhaustive because constraints are dropped from the list. Medium-term memory plays a role similar to nogood constraints obtained from the inference dual, which tend to exclude solutions similar to solutions that have been tried before (although the constraints imposed by medium-term memory may exclude optimal solutions if they remain on the list long enough). This suggests that, rather than design the tabu list in an ad hoc manner, one can use an inference dual of the subproblem to obtain tabu items.

Suppose, for example, that the neighborhood in iteration k is obtained by fixing a tuple inline image of some of the variables to inline image, so that the subproblem is (8). An optimal solution of the subproblem is the best solution in the neighborhood. A nogood cut inline image is obtained from the solution of the inference dual (9). Now the nogood constraint LBinline imageLBinline image can be added to the tabu list. This excludes not only solutions x in which inline image, but additional solutions that are similar in the sense that they cannot have a better value when the subproblem is solved.

This mechanism also provides a principled way to define the next neighborhood. We can fix inline image to a value inline image that satisfies all the nogood constraints in the current tabu list, perhaps while minimizing a function inline image that approximates the objective function value inline image. Due to the nogood constraints in the tabu list, this neighborhood will differ from those created recently. When the same variables inline image are fixed in each iteration, a tabu search of this kind becomes a heuristic form of Benders decomposition. Selecting the next solution, subject to the tabu list, corresponds solving the master problem. Even when inline image changes, the search becomes an exact method when all the nogoods added to the tabu list are retained.

As an example, consider a TSP on six cities with symmetric distances as shown in Table 2 (an infinite distance indicates that the edge is missing). The objective is to find a Hamiltonian cycle of minimum length. Let inline image be the city that follows city i in the cycle. We will define the first neighborhood by fixing inline image, the second neighborhood by fixing inline image, and so forth cyclically. Table 3 displays an exhaustive search. In the first line of Table 3, a neighborhood of size 3 is defined by fixing inline image, and the best solution in the neighborhood is shown. We use “enumerative nogoods” rather than bounds by keeping track of which solutions have been examined. Thus, we place inline image on the tabu list. We define the next neighborhood by fixing inline image at their current values. Only one solution in the neighborhood of 3 satisfies the tabu list, indicated by the notation 3(1). As the search proceeds, all nogoods are retained on the tabu list.

Table 2. Intercity distances for a traveling salesman problem
 23456
17544
2 876
3  38
4   47
5    5
Table 3. Exhaustive tabu search
IterationNeighborhoodSizeSolutionValueTabu list
1.inline image3(3)x  = (2, 3, 4, 5, 6, 1)31inline image
2.inline image3(1)x  = (6, 3, 4, 5, 1, 2)29inline image
     inline image
3.inline image3(1)x  = (6, 3, 4, 5, 1, 2)30inline image
     inline image
     inline image
4.inline image8(4)x  = (3, 6, 2, 5, 1, 4)34inline image
     inline image
     inline image
5.inline image3(2)x  = (2, 6, 5, 3, 1, 4)33inline image
     inline image
     inline image
     inline image
6.inline image8(3)x  = (5, 1, 2, 3, 6, 4)34inline image
     inline image
     inline image
7.inline image2(1)x  = (5, 1, 4, 6, 3, 2)35inline image
     inline image
     inline image
     inline image
8.inline image3(1)x  = (6, 1, 4, 2, 3, 5)34inline image
     inline image
     inline image
9.inline image3(2)x  = (3, 6, 4, 2, 1, 5)30inline image
     inline image
     inline image
     inline image
10.inline image8(2)x  = (6, 3, 1, 2, 4, 5)33inline image
     inline image
     inline image
inline image     
20.inline image8(1)x  = (3, 4, 2, 6, 1, 5)36inline image
     inline image
     inline image
     inline image
     inline image
21.0   

If the tabu list excludes the entire neighborhood, we enlarge the neighborhood by fixing fewer variables. This occurs in iterations 4, 6, 10, and 20. In the final iteration, we must expand the neighborhood to the entire search space by fixing no variables and enumerate all solutions that satisfy the tabu list. As it happens, there are no such solutions, and the search is complete, having found two optimal tours of length 29.

Table 4 displays an inexhaustive tabu search based on the same nogoods. The search is converted to a heuristic algorithm simply by dropping all but the two most recent nogoods on the tabu list. It proceeds identically with the exhaustive search through iteration 7. In iteration 8, the current tabu list allows a better solution (value 30), and from there out the search diverges from the exhaustive search. The search continues as long as desired.

Table 4. Inexhaustive tabu search
IterationNeighborhoodSizeSolutionValueTabu list
1.inline image3(3)x  = (2, 3, 4, 5, 6, 1)31inline image
2.inline image3(1)x  = (6, 3, 4, 5, 1, 2)29inline image
     inline image
3.inline image3(1)x  = (6, 3, 4, 5, 1, 2)30inline image
     inline image
4.inline image8(4)x  = (3, 6, 2, 5, 1, 4)34inline image
     inline image
5.inline image3(2)x  = (2, 6, 5, 3, 1, 4)33inline image
     inline image
6.inline image8(3)x  = (5, 1, 2, 3, 6, 4)34inline image
7.inline image2(1)x  = (5, 1, 4, 6, 3, 2)35inline image
     inline image
8.inline image3(2)x  = (3, 1, 4, 5, 6, 2)30inline image
     inline image
9.inline image3(2)x  = (6, 4, 3, 5, 1, 2)29inline image
     inline image
10.inline image2(1)x  = (3, 6, 2, 5, 1, 4)34inline image
     inline image
11.inline image3(2)x  = (2, 6, 5, 3, 1, 4)35inline image
     inline image
inline image     

An inexhaustive tabu search can be converted to an exhaustive one simply by retaining all enumerative nogoods on the tabu list, but one must take care that the nogoods are valid (do not exclude feasible solutions). When medium-term memory is exercised by excluding components of a solution, the resulting nogoods are frequently invalid. This can be remedied by generating a valid nogood, as well, in each iteration. The valid nogoods are retained, and the invalid ones dropped after a time as in traditional tabu search. The generation of invalid nogoods can then be discontinued after a desired number of iterations, at which point the search is run to completion with only valid nogoods.

4.4. Evolutionary algorithms

“Evolutionary algorithms” represent one of several “social” metaheuristics in which an evolving population of solutions share information with each other. Other metaheuristics in this category include ant colony optimization and particle swarm optimization, discussed below. At each stage of evolution, the current population can be viewed as the feasible set of a problem restriction. These algorithms therefore search over problem restrictions, as does local search. Unlike local search, however, the solution population generally does not form a neighborhood in any interesting sense.

The best-known evolutionary algorithm is a “genetic algorithm” (Barricelli, 1963; Holland, 1975; Rechenberg, 1973), which is based on mating and survival of the fittest. Each member of the population has a “genotype” that encodes a possible solution of the problem to be solved. In each iteration, some or all members of the solution population mate to produce an offspring whose genotype is a mixture of genes from the parents. The new genotype is obtained by a “crossover” operation that may simply splice together subsequences from the parental genotypes. Random changes or “mutations” may be introduced to diversify the gene pool. Some offspring are lucky enough to inherit superior traits from both parents and therefore improve the quality of the population. The worst solutions are removed from the population, representing survival of the fittest, and the next iteration begins. After a number of generations, the population is examined to find the best solution.

This is a case in which solving a relaxation of the current restriction guides the search, as in branch-and-bound search, although the mechanism is very different. In a genetic algorithm, enlarging the population to include offspring in effect relaxes the current restriction (Fig. 12). The relaxation is solved by evaluating the members of the population to identify the fittest. The next restriction consists of those solutions identified. There is no obvious role for relaxation bounding in this model, however.

image

Figure 12. Genetic algorithm interpreted as a search over relaxations of problem restrictions. The “solution” of the relaxation (identification of the fittest solutions) determines the next restriction (population).

Download figure to PowerPoint

The inference dual of the problem restriction is uninteresting, because it is solved simply by examining all the solutions in the population and selecting the fittest. However, rather than defining an inference dual based on “deduction,” one might use “induction.” That is, one could examine the current population for characteristics that tend to predict good solution values, perhaps using regression analysis. This might result in a function LBinline image that predicts an objective function value based on whether x has certain characteristics. Then a nogood bound would have the form, “v is probably bounded below by LBinline image.” This could guide the choice of parents to mate in future generations, or even the design of the crossover operation.

An alternate interpretation of genetic algorithms (Fig. 13) sees them as local search algorithms in which the current population P is regarded as a single solution. The value of P depends somehow on the fitness of the gene pool, perhaps the average value of the genotypes in P. A neighborhood of P is defined by adding offspring to obtain inline image, and neighboring populations are subsets of inline image having a specified size. This neighborhood is the feasible set of a problem restriction, which is solved by selecting the fittest population in the neighborhood. At termination, the best solution in the current population P is selected.

image

Figure 13. Genetic algorithm interpreted as local search. The current “solution” is the population, and each neighboring “solution” is a subset of the population and offspring.

Download figure to PowerPoint

Relaxation bounding can play a role in this model, as a device for sizing neighborhoods. If inline image is the best population fitness obtained so far, offspring can be created until P’s neighborhood contains a population with fitness better than inline image. In effect, neighborhoods that lack this property are pruned. So we enlarge the feasible set until the subproblem has an acceptable solution, as in variable-depth neighborhood search, rather than restricting the subproblem until it becomes soluble, as in branching search.

4.5. Ant colony optimization

“Ant colony optimization” (Dorigo, 1992; Dorigo and Gambardella, 1997) mimics the seeking behavior of ants, who communicate with other ants by depositing pheromones as they explore for food. The idea is best explained by example, such as the TSP.

Initially, all the ants of the colony are in city 1. In each iteration, each ant crawls from its current location i to city j with probability proportional to inline image, where inline image is the density of accumulated pheromone deposit on the trail from i to j, and inline image is the distance from i to j (Fig. 14). Each ant deposits pheromone at a constant rate while crawling, and a certain fraction of the pheromone evaporates between each iteration and the next. Each ant remembers where it has been and does not visit the same city twice until all cities have been visited. After returning to city 1, the ants forget everything and start over again. When the process terminates, the shortest tour found by an ant is selected.

image

Figure 14. Ant colony optimization for the TSP.

Download figure to PowerPoint

In each iteration, each ant carries out a randomized greedy heuristic in which the probabilities are defined by pheromone deposits and distances. Thus, the ant search is basically a GRASP with a constructive phase but no local search phase. Each variable assignment in the constructive phase creates a problem restriction, and we therefore have a search over problem restrictions as in branching search. Relaxation bounding can be introduced as described in section 'Local search'. If at any point in the greedy algorithm the relaxation value is worse than an incumbent solution, the tree is pruned at that point. The ant immediately returns to the anthill and begins another tour.

Ant colony optimization can be converted to an exact algorithm, in much the same way as the constructive phase of a GRASP. The ants collectively create a search tree in which the branching decisions are influenced by pheromones. We can simply keep track of this tree and prevent an ant from entering a subtree that has already been explored. Depending on the problem structure, we may be able to introduce backjumping with the constraint-directed search mechanism described in section 'The algorithmic framework'.

4.6. Particle swarm optimization

“Particle swarm optimization” (Kennedy and Eberhart, 1995; Shi and Eberhart, 1998) is normally presented as a method for continuous global optimization, although it can be applied to discrete problems as well.

The goal is to search a space of many dimensions for the best solution. A swarm of particles are initially distributed randomly through the space. Certain particles have two-way communication with certain others. In each iteration, each particle moves randomly to another position, but with higher probability of moving closer to a communicating particle that occupies a good solution. After many iterations, the best solution found is selected.

The current particle positions represent the feasible set of a problem restriction, and the method therefore searches over problem restrictions. The restriction is solved in the sense that all of the positions are evaluated, although no particular solution is selected until the algorithm terminates.

The particle swarm algorithm can be viewed as constraint-directed search in which the inference dual uses inductive inference, as suggested for genetic algorithms in section 'Evolutionary algorithms'. The inference dual is again solved simply by evaluating all solutions of the subproblem. An examination of the solution values suggests that solutions in certain regions tend to be better, and particles therefore gravitate toward these regions in the next iteration. Thus, information that is inductively inferred from the optimality proof guides the choice of future restrictions. One could carry this further by analyzing the solution set more closely, perhaps to identify specific characteristics that tend to predict better solution values. Particles could then move in directions that tend to favor these characteristics. Constraint-directed search based on inductive inference is obviously related to machine learning and learning-based algorithms in general, and there may be some value in investigating how these fit into the framework suggested here.

5. Conclusions

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References

This paper presented a framework in which many exact and heuristic methods can be seen as having common structure that permits some degree of unification, as summarized in Tables 5 and 6. It interprets solution algorithms as primal–dual methods in which the primal component searches over problem restrictions, and the dual component obtains bounds on the optimal value. In particular, the concept of an inference dual provides the basis for constraint-directed search, an algorithmic scheme shared by many exact and heuristic methods. The motivations behind unification are (a) to encourage the exchange of algorithmic techniques between exact and heuristic methods and (b) to design solution methods that transition gracefully from exact to heuristic modes as problem instances scale up.

Table 5. Summary of exact methods
 RestrictionsRelaxation dualNogoods fromTo convert to a
Methodenumeratedproviding boundsinference dualheuristic method
DPLL (for satisfiability)Leaf nodes Conflict clausesDrop some conflict
 of search tree  clauses
Simplex (for LP)Edges ofSurrogate dualReduced costsTerminate
 polyhedron  prematurely
Branch and boundLeaf nodesLP boundsConflict analysisForget tree and
(for IP)of search tree  use nogood constraints
Branch and boundIncompleteUphill search over Terminate
as local searchsearch treesincomplete trees prematurely
BendersSubproblemsMaster problemLogic-basedDrop some Benders
decomposition  Benders cutscuts
Table 6. Summary of heuristic methods
 RestrictionsRelaxation dualNogoods fromTo convert to an
Methodenumeratedproviding boundsinference dualexact method
Local searchNeighborhoodsAdjustment of Search over partial
(e.g., for TSP)(e.g., 2-opt nbhds)neighborhood size solutions
GRASPNodes of incompleteAs in branch and Do not forget nodes,
(e.g., for TSP with time windows)search treebound complete the tree
Tabu searchNeighborhoods Items on tabu listSearch over partial
(e.g., for TSP with   solutions; dynamic
time windows)   backtracking
Genetic algorithmPopulations Crossover guidance from 
   inductive inference dual 
Genetic algorithmSubsets of populationControl ofLogic-based 
as local searchplus offspringneighborhood size  
Ant colonySame as GRASPAs in GRASP As in GRASP
optimization    
Particle swarmSets of swarm Relocation guidance from 
optimizationlocations inductive inference dual 

References

  1. Top of page
  2. Abstract
  3. 1. Introduction
  4. 2. Fundamentals
  5. 3. Exact methods
  6. 4. Heuristic methods
  7. 5. Conclusions
  8. Acknowledgments
  9. References
  • Achterberg, T., 2007. Conflict analysis in mixed integer programming. Discrete Optimization 4, 420.
  • Ahuja, R.K., Ergun, O., Orlin, J.B., Punnen, A.P., 2002. A survey of very large scale neighborhood search techniques. Discrete Applied Mathematics 123, 75102.
  • Barricelli, N.A., 1963. Numerical testing of evolution theories. Part II: preliminary tests of performance, symbiogenesis and terrestrial life. Acta Biotheoretica 16, 99126.
  • Beame, P., Kautz, H., Sabharwal, A., 2003. Understanding the power of clause learning. International Joint Conference on Artificial Intelligence (IJCAI 2003), Acapulco, Mexico.
  • Benchimol, P., Régin, J.-C., Rousseau, L.-M., Rueher, M., van Hoeve, W.-J., 2010. Improving the Held and Karp approach with constraint programming. In Lodi, A., Milano, M. and Toth, P. (eds). Proceedings of the International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2010), Vol. 6140 of Lecture Notes in Computer Science. Springer, New York, pp. 4044.
  • Benders, J.F., 1962. Partitioning procedures for solving mixed-variables programming problems. Numerische Mathematik 4, 238252.
  • Benichou, M., Gautier, J.M., Girodet, P., Hentges, G., Ribiere, R., Vincent, O., 1971. Experiments in mixed-integer linear programming. Mathematical Programming 1, 7694.
  • Bixby, R.E., Cook, W., Cox, A., Lee, E.K., 1995. Parallel mixed integer programming. Technical report CRPC-TR95554, Center for Research on Parallel Computation, Rice University, Houston, TX.
  • Bliek, C., 1998. Generalizing dynamic and partial order backtracking. National Conference on Artificial Intelligence (AAAI 1998), Madison, WI, pp. 319325.
  • Blum, C., Puchinger, J., Raidl, G., Roli, A., 2011. Hybrid metaheuristics. In van Hentenryck, P. and Milano, M. (eds). Hybrid Optimization: The Ten Years of CPAIOR, Springer, New York, pp. 305336.
  • Davis, M., Logemann, G., Putnam, H., 1962. A machine program for theorem proving. Communications of the ACM 5, 394397.
  • Davis, M., Putnam, H., 1960. A computing procedure for quantification theory. Journal of the ACM 7, 201215.
  • Dhyani, K., Gualandi, S., Cremonesi, P., 2010. A constraint programming approach to the service consolidation problem. In Lodi, A., Milano, M., and Toth, P. (eds). Proceedings of the International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2010), Vol. 6140 of Lecture Notes in Computer Science, Springer, New York, pp. 97101.
  • Dorigo, M., 1992. Optimization, learning and natural algorithms. PhD thesis, Politecnico di Milano.
  • Dorigo, M., Gambardella, L.M., 1997. Ant colony system: a cooperative learning approach to the traveling salesman problem. IEEE Transactions on Evolutionary Computation 1, 5366.
  • El Hachemi, N., Gendreau, M., Rousseau, L.-M., 2009. Hybrid LS/CP approach to solve the weekly log-truck scheduling problem. In van Hoeve, W.-J. and Hooker, J.N. (eds). Proceedings of the International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2009), Vol. 5547 of Lecture Notes in Computer Science, Springer, New York, pp. 319320.
  • Feo, T.A., Resende, M.G.C., Smith, S.H., 1994. A greedy randomized adaptive search procedure for maximum independent set. Operations Research 42, 860878.
  • Feo, T.A., Resende, M.G.C., Smith, S.H., 1995. Greedy randomized adaptive search procedures. Journal of Global Optimization 6, 109133.
  • Gaschnig, J., 1978. Experimental studies of backtrack vs. Waltz-type vs. new algorithms for satisficing-assignment problems. Proceedings, 2nd National Conference of the Canadian Society for Computational Studies of Intelligence, Toronto, Canada, pp. 1921.
  • Gautier, J.M., Ribiere, R., 1977. Experiments in mixed-integer linear programming using pseudo-costs. Mathematical Programming 12, 2647.
  • Ginsberg, M.L., 1993. Dynamic backtracking. Journal of Artificial Intelligence Research 1, 2546.
  • Ginsberg, M.L., McAllester, D.A., 1994. GSAT and dynamic backtracking. Principles and Practice of Constraint Programming (CP 1994), Vol. 874 of Lecture Notes in Computer Science, Springer, New York, pp. 216225.
  • Glover, F., 1989. Tabu search: part I. ORSA Journal on Computing 1, 190206.
  • Golden, B.L., Stewart, W.R., 1985. Empirical analysis of heuristics. In Lawler, E.L., Lenstra, J.K., Rinnooy Kan, A.H.G. and Shmoys, D.B. (eds). The Traveling Salesman Problem: A Guided Tour of Combinatorial Optimization, Wiley, New York, pp. 207249.
  • Gomes, C.P., Kautz, H., Sabharwal, A., Selman, B., 2008. Satisfiability solver. In van Harmelen, F., Lifschitz, V., and Porter, B., (eds). Handbook of Knowledge Representation, Elsevier, Amsterdam, pp. 89134.
  • Hansen, P., 1986. The steepest ascent mildest descent heuristic for combinatorial programming. Presentation at Congress on Numerical Methods in Combinatorial Optimization, Capri.
  • Holland, J.H., 1975. Adaptation in Natural and Artificial Systems. University of Michigan Press, Ann Arbor, MI.
  • Hooker, J.N., 2000. Logic-Based Methods for Optimization: Combining Optimization and Constraint Satisfaction. John Wiley, New York.
  • Hooker, J.N., 2005. Unifying local and exhaustive search. In Villaseñor, L. and Martinez, A.I. (eds). Avances en la Ciencia de la Computación (ENC 2005), Puebla, Mexico, pp. 237243.
  • Hooker, J.N., 2006. Duality in optimization and constraint satisfaction. In Beck, J.C. and Smith, B.M. (eds). Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2006), Vol. 3990 of Lecture Notes in Computer Science, Springer, New York, pp. 315.
  • Hooker, J.N., 2007a. Integrated Methods for Optimization. Springer, New York.
  • Hooker, J.N., 2007b. Planning and scheduling by logic-based Benders decomposition. Operations Research 55, 588602.
  • Hooker, J.N., 2012. Integrated Methods for Optimization (2nd edn). Springer, New York.
  • Hooker, J.N., Ottosson, G., 2003. Logic-based Benders decomposition. Mathematical Programming 96, 3360.
  • Hooker, J.N., Yan, H., 1995. Logic circuit verification by Benders decomposition. In Saraswat, V. and Van Hentenryck, P. (eds). Principles and Practice of Constraint Programming: The Newport Papers, MIT Press, Cambridge, MA, pp. 267288.
  • Kennedy, J., Eberhart, R., 1995. Particle swarm optimization. Proceedings of IEEE International Conference on Neural Networks, Perth, Australia, pp. 19421948.
  • Khichane, M., Albert, P., Solnon, C., 2010. Strong combination of ant colony optimization with constraint programming optimization. In Lodi, A., Milano, M. and Toth, P. (eds). Proceedings of the International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2010), Vol. 6140 of Lecture Notes in Computer Science, Springer, New York, pp. 232246.
  • Kirkpatrick, S., Gelatt, C.D., Vecchi, M.P., 1983. Optimization by simulated annealing. Science 220, 671680.
  • Lin, S., Kernighan, B., 1973. An effective heuristic algorithm for the traveling salesman problem. Operations Research 21, 498516.
  • McAllester, D.A., 1993. Partial order backtracking. Technical Report, AI Laboratory, MIT, Cambridge, MA.
  • Moskewicz, M.W., Madigan, C.F., Zhao, Y., Zhang, L., Malik, S., 2001. Chaff: engineering an efficient SAT solver. Proceedings of the 38th Design Automation Conference (DAC 2001), Las Vegas, NV, pp. 530535.
  • Pham, Q.D., Deville, Y., Van Hentenryck, P., 2010. Constraint-based local search for constrained optimum paths problems. In Lodi, A., Milano, M. and Toth, P. (eds). Proceedings of the International Conference on Integration of AI and OR Techniques in Constraint Programming for Combinatorial Optimization Problems (CPAIOR 2010), Vol. 6140 of Lecture Notes in Computer Science, Springer, New York, pp. 267281.
  • Pisinger, D., Ropke, S., 2010. Large neighborhood search. In Gendreau, M. and Potvin, J.-Y. (eds). Handbook of Metaheuristics, Springer, New York, pp. 399420.
  • Prestwich, S., 2004. Exploiting relaxation in local search. First International Workshop on Local Search Techniques in Constraint Satisfaction (LSCS 2004), Toronto, Canada.
  • Rechenberg, I., 1973. Evolutionsstrategie. Holzmann-Froboog, Stuttgart.
  • Sandholm, T., Shields, R., 2006. Nogood learning for mixed integer programming. Workshop on Hybrid Methods and Branching Rules in Combinatorial Optimization, Montreal, Canada.
  • Shaw, P., 2011. Constraint programming and local search hybrids. In van Hentenryck, P. and Milano, M. (eds). Hybrid Optimization: The Ten Years of CPAIOR, Springer, New York, pp. 271304.
  • Shi, Y., Eberhart, R., 1998. A modified particle swarm optimizer. Proceedings of IEEE International Conference on Neural Networks, Anchorage, AK, pp. 6973.
  • Stallman, R.M., Sussman, G.J., 1977. Forward reasoning and dependency-directed backtracking in a system for computer-aided circuit analysis. Journal of Artificial Intelligence 9, 135196.
  • Yunes, T.H., Aron, I., Hooker, J.N., 2010. An integrated solver for optimization problems. Operations Research 58, 342356.