Improved branchcutandprice for capacitated vehicle routing
 788 Downloads
 7 Citations
Abstract
The best performing exact algorithms for the capacitated vehicle routing problem developed in the last 10 years are based in the combination of cut and column generation. Some authors only used cuts expressed over the variables of the original formulation, in order to keep the pricing subproblem relatively easy. Other authors could reduce the duality gaps by also using a restricted number of cuts over the master LP variables, stopping when the pricing becomes prohibitively hard. A particularly effective family of such cuts are the subset row cuts. This work introduces a technique for greatly reducing the impact on the pricing of these cuts, thus allowing much more cuts to be added. The newly proposed branchcutandprice algorithm also incorporates and combines for the first time (often in an improved way) several elements found in previous works, like route enumeration and strong branching. All the instances used for benchmarking exact algorithms, with up to 199 customers, were solved to optimality. Moreover, some larger instances with up to 360 customers, only considered before by heuristic methods, were solved too.
Keywords
Integer programming Column generation Cut separation Algorithmic engineeringMathematics Subject Classification
90C10 Integer programming 90C39 Dynamic programming 90C57 Polyhedral combinatorics branchandbound branchandcut1 Introduction
The capacitated vehicle routing problem (CVRP) was defined by Dantzig and Ramser [10] as follows. The input consists of a set of \(n+1\) points, a depot and n customers; an \((n+1) \times (n+1)\) matrix \([c_{ij}]\) with the travel costs between every pair of points i and j; an ndimensional demand vector \([d_i]\) giving the amount to be collected from customer i; and a vehicle capacity Q. A solution is a set of routes, starting and ending at the depot, that visit every customer exactly once. The only constraint on a route is that the sum of the demands of its customers does not exceed the vehicle capacity Q. The objective is to find a solution with minimum total cost. Many authors also assume that the number of routes is fixed to an additional input number K. The CVRP is a widely studied problem due to its own applications, since it can model adequately a significant number of real logistic systems. Furthermore, it plays a particularly important role on general vehicle routing research, for being the most basic and prototypical VRP variant.
Column generation has been used in exact algorithms for the vehicle routing problem with time windows (VRPTW) since Desrochers et al. [11]. This technique performed very well on tightly constrained instances (those with narrow time windows). As the CVRP can be regarded as the particular case of VRPTW where time windows are arbitrarily large, column generation was viewed as a nonpromising approach for the problem. In fact, in the early 2000s, the best performing algorithms for the CVRP were branchandcut algorithms that separated quite complex families of cuts identified by polyhedral investigation (see Naddef and Rinaldi [22]). In spite of their sophistication, some instances from the literature with only 50 customers could not be solved to optimality [20]. At that moment, the branchcutandprice algorithm (BCP) algorithm in Fukasawa et al. [12] showed that the combination of cut and column generation could be much more effective than each of those techniques taken alone.
According to the classification proposed in Poggi and Uchoa [28], the BCP algorithm in [12] only uses robust cuts. A cut is said to be robust when the value of the dual variable associated to it can be translated into costs in the pricing subproblem. Therefore, the structure and the size of that subproblem remain unaltered, regardless of the number of robust cuts added. On the other hand, nonrobust cuts are those that change the structure and/or the size of the pricing subproblem, each additional cut makes it harder. Robustness is a desirable property of a BCP. Even with good pricing heuristics, at least one call to the exact pricing is necessary to establish a valid dual bound. With the addition of nonrobust cuts, there is a risk of having to solve to optimality an intractable subproblem. Nevertheless, since Jepsen et al. [17] and Baldacci et al. [2] it is known that some nonrobust cuts can be effectively used, at least if their separation is restricted in order to avoid an excessive impact on the pricing. While the adjective nonrobust focuses on their negative aspect; some authors call them strong cuts, focusing on their positive aspect, a greater potential for significantly reducing the integrality gaps.
1.1 Literature review
 1.
Fukasawa et al. [12] presented a BCP algorithm where the columns are associated to the qroutes without kcycles [16]. The separated cuts are the same used in previous algorithms over the edge CVRP formulation. Those cuts are robust with respect to qroute pricing. If the column generation at the root node is found to be too slow, the algorithm may automatically switch to a branchandcut. This may be advantageous in some instances. All benchmark instances from the literature with up to 134 customers could be solved to optimality, an expressive improvement over previous methods.
 2.
Baldacci et al. [2] presented an algorithm based on column and cut generation. The columns are associated to elementary routes. Besides cuts for the edge formulation, strengthened capacity cuts and clique cuts are separated. Those later cuts are effective but nonrobust. An important new idea is introduced. Instead of branching, the algorithm finishes in the root node (therefore, it is not a BCP) by enumerating all elementary routes with reduced cost smaller than the duality gap. A setpartitioning problem containing all those routes is then given to a MIP solver. The algorithm could solve almost all instances solved in [12], usually taking much less time. However, the exponential nature of some algorithmic elements, in particular the route enumeration, made it fail on some instances with many customers per route.
 3.
Pessoa et al. [24] presented some improvements over [12]. Cuts from an extended formulation with load indices were also separated. Those cuts do not change the complexity of the pricing of qroutes by dynamic programming. Additionally, the idea of performing elementary route enumeration and MIP solving to finish a node was borrowed from [2]. However, in order to avoid a premature failure when the root gap is too large, it was hybridized with traditional branching. The overall improvement was not sufficient for solving larger instances.
 4.
The algorithm by Baldacci et al. [3] improved upon [2]. It introduces the concept of ngroutes, a route relaxation that is more effective than the qroutes without kcycles. Instead of clique cuts, subset row cuts ([17]) and weak subset row cuts, that have less impact on the pricing, are separated. The resulting algorithm is not only faster on average, it is much more stable than the algorithm in [2], being able to solve even some instances with many customers per route.
 5.
Contardo [8] introduced new twists on the use of nonrobust cuts and on route enumeration. The columns are associated with qroutes without twocycles, a relatively poor relaxation. The partial elementarity of the routes is enforced by nonrobust strong degree cuts. Robust cuts from edge formulation and nonrobust strengthened capacity cuts and subset row cuts are also separated. The enumeration of elementary routes is directed to a pool of columns. As soon as the duality gap is sufficiently small to produce a pool with reasonable size (a few million routes), the pricing starts to be performed by inspection. From this point, an aggressive separation of nonrobust cuts can be performed, leading to very small gaps. The reported computational results are very consistent. In particular, the hard instance Mn151k12 (150 customers, 12 routes) was solved to optimality for the first time (in 6 hours), setting a new record.
 6.
Røpke [32] went back to robust BCP. Its linear relaxation differs from [12] only by the use of the more effective ngroutes. The power of the algorithm comes mainly from a sophisticated and aggressive strong branching, able to reduce significantly the average size of the enumeration trees. The overall results are comparable with the results in [3, 8]. A long run of that algorithm (5.5 days) could also solve Mn151k12.
 7.
Finally, Contardo and Martinelli [9] improved upon [8]. Instead of qroutes without twocycles, ngroutes are used. Moreover, the performance of the dynamic programming pricing was enhanced by the use of the DSSR technique [4, 31] and edge variables are fixed by reduced costs, using the procedure proposed in [15]. The computational results were also improved. For example, instance Mn151k12 could be solved in less than 3 h.
1.2 New branchcutandprice algorithm

It uses limited memory subset row cuts (lmSRCs), the most important original contribution introduced here. While the traditional SRCs are known to be effective, their practical use has been restricted by their large impact on the pricing. The lmSRCs are a weakening of the SRCs. This weakening can be controlled and dynamically adjusted, making the lmSRCs as effective in improving the lower bounds as the traditional SRCs, but still much less costly in the pricing. In fact, in many instances from the literature, including quite large ones, it is possible to separate lmSRCs to obtain bounds as good as those that would be obtained by separating all SRCs with cardinality up to 5.

The underlying formulation used in the BCP has extended arcload variables. This allows a new and effective scheme for fixing of variables by Lagrangean bounds (superior to the fixing in [15]), with direct benefits on the pricing.

The columns in the BCP are associated with ngroutes. The corresponding pricing subproblem is solved by a labeling algorithm that must also consider the dual variables of the lmSRCs. Its implementation is quite critical for the overall BCP performance. After experiments with a number of alternatives, the best performance was obtained by a bidirectional search that differs a little from that proposed in [30] because the concatenation of the labels is not necessarily performed at the half of the capacity. Completion bounds (similar to those in [8]) are also used for eliminating labels. Anyway, the exact pricing algorithm is called just a few times per BCP node, most of the iterations use effective heuristics.

In some instances, usually those with an average of more than 15 customers per route, column generation is prone to severe convergence problems. When this situation is detected, the BCP automatically starts performing dual stabilization, as described in [25].

Like in [24], the BCP hybridizes branching with route enumeration. Actually, it performs an aggressive hierarchical strong branching, with up to n candidates (partially) evaluated in the root node. The strong branching effort in each node depends on an estimate of the size of the subtree rooted in that node. The branching mechanism also keeps the history of candidate evaluations for helping on future decisions.

As soon as the gap of a BCP node is sufficiently small, the elementary routes that can be part of the optimal solution are enumerated into a pool. From that point, since the pricing will be performed by inspection, all lmSRCs may be immediately lifted to SRCs and additional nonrobust cuts, including cliques, may be separated. On larger instances this may not be enough to reduce the number of routes to a size tractable by a MIP solver. In those cases, a new idea is used: perform ordinary BCP branching. The pricing will continue to be performed by pool inspection, in both child nodes. Nodes are only finished by the MIP solver when the number of remaining routes is quite small.

The lmSRCs are still nonrobust. There are cases where several hundreds such cuts are being normally handled by the pricing algorithm, and then, the separation of a few dozen additional lmSRCs makes this algorithm 100 times slower. In this situation the BCP performs a rollback, where the offending cuts are removed even if the lower bound of the node is decreased. This is a completely original feature, not appearing in previous works.
This article is organized as follows. Section 2 presents the used formulations. Section 3 introduces the limited memory SRCs and their separation strategy. Section 4 describes the labeling algorithms used for pricing, for fixing variables by reduced costs and for enumerating routes. Section 5 presents the strong branching procedure, fully hybridized with the enumeration. Section 6 reports computational experiments. Finally, Sect. 7 contains a number of conclusions.
2 Formulations
A significantly stronger linear relaxation would be obtained if \(\varOmega \) was redefined as the set of elementary routes. On the other hand, the pricing subproblem would become strongly NPhard. While carefully designed labeling algorithms are now capable of pricing elementary routes on most instances from the literature with up to 199 customers [21], this is still too costly. A possible alternative is pricing qroutes without kcycles [16], a relaxation of the elementary routes that allows multiple visits to a customer, on the condition that at least k other customers are visited between successive visits. While pricing qroutes without threecycles is not much more costly than pricing ordinary qroutes [12], using values of k larger than 4 can make the algorithm too slow. A more recent alternative for imposing partial elementarity, used in this work, are the ngroutes [3]. For each customer \(i \in V_+\), let \(NG(i) \subseteq V_+\) be the ngset of i, defining its neighborhood. This may stand for the NG(i) (this cardinality is decided a priori) closest customers and includes i itself. An ngroute allows multiple visits to a customer i, on the condition that at least one costumer j such that \(i \notin NG(j)\) is visited between successive visits. Extensive experiments performed in [21] showed that the use of ngsets with size 8 already yields lower bounds comparable with the use of qroutes without 5cycles, but spending significantly less time. From now on, \(\varOmega \) is redefined to be a set of ngroutes.
3 Cuts
Even if \(\varOmega \) only contains elementary routes, the bounds given by (8)–(11) are not good enough to be the basis of efficient exact algorithms (gaps between 1 and 4 % are typical in the instances from the literature). For this purpose, the formulation must be reinforced with additional cuts. Cuts for the undirected edge formulation can be included in the DWM by using the transformation \(x_{ij} = \sum _{(i,j)^q \in A_Q} x_{ij}^q + \sum _{(j,i)^q \in A_Q} x_{ji}^q\). In this work, rounded capacity cuts and strengthened combs are separated by the CVRPSEP package [19]. All those cuts are robust, the effect of their dual variables is captured in the arcload reduced costs (12).

The cuts where \(C=3\) and \(p=1/2\) are called 3subset row cuts (3SRCs) and can be expressed as \(y_C^2 + y_C^3 + 2 y_C^4 + 2y_C^5 + \ldots \le 1\). Although they are very effective in improving the lower bounds, only a relatively small number of those cuts could be separated in [3, 8], and [9], in order to keep the pricing tractable. The first authors also used the Weak 3SRCs, a weakening of the 3SRCs where only the variables corresponding to routes that use an edge (i, j) such that \(i,j \in C\) have coefficient 1.

Taking \(C=1\) and \(p=1/2\), the 1subset row cuts (1SRCs) \(y_C^2 + y_C^3 + 2y_C^4 + \ldots \le 0\) are obtained. They are equivalent to the strong degree cuts \(y_C^1 \ge 1\) introduced in [8], in the sense that both families forbid cycles over a vertex i (\(C=\{i\}\)). Contardo also defined the weaker kcycle elimination cuts, that only forbid cycles over i of size k or less. Of course, these cuts can only be useful when the \(\varOmega \) set contains nonelementary routes.

The cuts where \(C=4\) and \(p=2/3\) are 4SRCs, expressed as \(y_C^2 + 2y_C^3 + 2y_C^4 + 3y_C^5 + 4y_C^6 + \ldots \le 2\).

There are two interesting families of cuts with \(C=5\). Those with \(p=1/3\) will be called 5,1SRCs, \(y_C^3 + y_C^4 + y_C^5 + 2y_C^6 \ldots \le 1\); whereas those with \(p=1/2\) are 5,2SRCs, having the format \(y_C^2 + y_C^3 + 2y_C^4 + 2y_C^5 + 3y_C^6 \ldots \le 2\). The latter family was already used in [8], and [9].
4 Labeling algorithms
In this section we present the algorithms used for pricing ngroutes, for fixing arcload variables by reduced costs, and for enumerating elementary routes. Those algorithms should take into account the following points: (i) the reduced cost of an arc, defined as (12), depends on its load q; (ii) some variables \(x_{a}^{q}\) may be already fixed to zero; and (iii) nonrobust lmSRCs may be present.
4.1 Pricing
4.1.1 Forward labeling

A first observation is that the state of an lmSRC s needs only to be explicitly present in labels corresponding to partial paths ending in M(s). For the remaining labels, this state is zero by definition, which means that \(\sigma _s\) will not play any role in the processing of their buckets. In other words, only the vertices in M(s) need to know about the existence of that cut. This allows the acceleration of the algorithm by a factor of \(\theta (n/M_{avg})\), where \(M_{avg}\) is the average size of the memory sets.

However, the crucial point for the improved algorithm efficiency is related to the dominance. If there are no SRCs, the maximum number of nondominated labels in a bucket F(i, q) is bounded by \(2^{NG(i)1}\), as follows from dominance conditions (iii) and (iv). If the cardinality of the ngsets is small (we used 8 in this work), the pricing is guaranteed to be reasonably fast (unless Q is very large). However, if a traditional SRC is added, its dual variable may make condition (iv) weaker in all buckets. As other SRCs are separated, this may quickly result in an exponential proliferation of nondominated labels. In practice, this severely limits the number of SRCs that can be used. In contrast, a lmSRC s with a small memory has much less impact because it can only weaken the dominance in the buckets of M(s). In practice, many more lmSRCs can be separated before the exponential proliferation of labels is observed. This is exemplified in Fig. 2. Let \(P_1\) be the solid path and \(P_2\) the dashed one, both paths ending in vertex i and having load q. A 3SRC with base set \(C=\{1,2,3\}\) may prevent \(L(P_1)\) from dominating \(L(P_2)\), even though no good completion of \(P_2\) visits C. On the other hand, a lm3SRC over the same C, having the memory set represented in the figure by filled circles, would not interfere with that dominance.
4.1.2 Bidirectional labeling
The forward and backward variants of the labeling are equivalent in terms of computational cost. However, as pointed out in [30], when forward labeling is used, most of the computational effort is spent in buckets with larger values of q, close to Q. This happens by combinatorial reasons, there are many more possible paths converging into a bucket F(i, q) if q is larger. In a similar way, when backward labeling is used, most of the computational effort is spent in buckets with small values of q. Therefore, it is often advantageous to perform bidirectional search: use the forward labeling for filling the buckets F(i, q) with \(q \le Q/2\) and backward labeling for filling the buckets B(i, q) with \(q > Q/2\). The minimum reduced cost paths can be obtained by an additional concatenation step. After implementing this bidirectional algorithm, we realized that the number of labels in the backward part was consistently larger (3–10 times more is typical) than in the forward part. This happens because the backward labeling has more starting labels. Therefore, the algorithm performance can be improved by better balancing both parts. This means that the concatenation will occur at a value (dynamically determined) larger than Q / 2.
4.1.3 Completion bounds

For a 3SRC or a 5,2SRC s, the value \(\sigma _s/2\) can be subtracted from the reduced cost of the arcs inside C(s).

For a 4SRC s, the value \(2\sigma _s/3\) can be subtracted from the reduced cost of the arcs inside C(s).
Table 10 in the appendix shows detailed results over a number of hard instances of five variants of the pricing: 1—forward labeling (Algorithm 3); 2—bidirectional labeling with concatenation at Q / 2; 3—bidirectional labeling with dynamic determination of the concatenation point (Algorithm 5); 4—the later algorithm with mild use of completion bounds (\(n_S'\) is small); 5—the same algorithm with aggressive use of completion bounds (\(n_S'\) is larger).
4.1.4 Nonrobustness control
Even with all the previously described enhancements, the addition of too many lmSRCs will still cause an exponential explosion of the number of labels in the pricing algorithms. Worse, it is not possible to predict when the explosion will occur. We have seen examples of runs where several hundreds such cuts are being normally handled by the pricing algorithm and then, at some node deep in the tree, the separation of a few dozen additional lmSRCs makes this algorithm 100 times or even 1000 times slower. In some cases the BCP crashed due to memory overflow.
The first strategy tried for avoiding such failures was setting a conservative limit on \(n_S\) and stopping the separation of lmSRCs after it is reached. A much better strategy is to handle the lmSRCs dynamically. In the beginning of the root node, when no lmSRCs were added, the pricing still has a pseudopolynomial complexity (assuming that the size of the ngsets is fixed). Those robust runs of the pricing are used to establish a baseline BL on the number of labels. The algorithm proceeds by separating rounds of lmSRCs. The number of labels in the pricing is likely to increase, values up to 5BL are always acceptable, larger values may be tolerated if the rate of lower bound improvement is still good. This mechanism determines, for each node, when separation will stop and enumeration/branching will be called. However, if the number of labels in a call of the pricing exceeds 50BL, the BCP concludes that an exponential explosion is occurring. The pricing is aborted and the node is rolled back to its previous state before the last round of cuts. This means that the lmSRCs added in that round, even if they are active, are removed.
4.1.5 Heuristic pricing
4.2 Variable fixing by reduced costs
The labeling algorithms are also employed in a key part of the BCP algorithm: the elimination of variables by reduced costs. A full separated run of both forward and backward labeling should be performed. The minimum reduced cost of a route passing by an arc \((i,j)^q \in A_Q\), denoted by \(\bar{C}_{ij}^q\), can be obtained by concatenating the labels in F(i, q) from the forward run with the labels in \(B(j,q+d_j)\) from the backward run. If \(\bar{C}_{ij}^q\) is larger than the gap of the Lagrangean bound associated to the current dual solution with respect to the best known integer solution (see [26]), then \(x_{i,j}^q\) can be fixed to zero. The pseudocode of our variable fixing is presented by Algorithm 6. It is quite similar to that shown in Algorithm 5, the bidirectional labeling procedure. Note that the concatenation here also relies on the fact that labels are ordered by reduced cost inside buckets.
A similar fixing procedure was also proposed in [15], but it is weaker because it only removes an arc \((i,j) \in A\), if a single particular dual solution allows removing \((i,j)^q\) for all values of q. On the other hand, as our BCP already works on the arcload formulation, individual arcs \((i,j)^q\) can be naturally removed. For instance, it is quite typical that, at a certain point of the BCP, 95 % of the arcload variables were already fixed to zero, while the fixing on arcs would not achieve 80 %.
4.3 Route enumeration
Baldacci et al. [2] introduced a route enumeration based approach in order to close the duality gap after the root node. An elementary route can only be part of a solution that improves the best known upper bound if its reduced cost is smaller than the gap. The enumeration of elementary routes may be performed by a label setting algorithm, producing a set partitioning problem that is given to a general MIP solver. This may work very well if the size of the set R of enumerated routes is not too large. If \(R<\) 20,000 the set partitioning is usually solved in less than 1 minute in a modern machine. Larger values of R may cause the MIP solver to take too much time, \(R>\) 100,000 is often unpractical.
Contardo [8] proposed another strategy in order to better profit from the route enumeration. The enumeration is performed even if the resulting R has a few million routes, which are stored in a pool. The column and cut generation proceeds. However, instead of using a labeling algorithm, the pricing starts to be performed by inspection in the pool. Now, the nonrobust cuts have little impact in the pricing complexity. Therefore, they may be separated in a very aggressive way. This usually increases substantially the lower bounds, allowing reductions in the pool size by fixing variables (that now are routes) by reduced costs. For example, he reported that the enumeration of instance Mn151k12 with gap of 5 units produced a pool with 4M routes. The separation of nonrobust cuts then reduced the gap to 1.5 and the final pool only had 13K routes. The resulting set partitioning was easily solved, finishing the instance.
A similar enumeration procedure could also be built by extending labels backwards. For this purpose, the list \(\mathcal {Q}\) is initialized with starting labels at the depot carrying all possible loads \(1 \le q \le Q\). The backward enumeration in itself has no advantage. However, as happens with the pricing, it can be used as a component of a significantly faster bidirectional enumerator (as already done in [2] and in [9]). In this case, the forward and backward enumeration algorithms are run up to a point around Q / 2 and a concatenation phase is used for retrieving the elementary paths with reduced cost smaller than the gap.
5 Strong branching
It is clear that route enumeration is an important element in some of the best performing algorithms for the CVRP, being able of drastically reducing the running times of some instances. Nevertheless, it is disturbing to consider that route enumeration, no matter how cleverly done, is an inherently exponential space procedure (it would remain exponential even if P \(=\) NP) that is bound to fail on larger/harder instances. However, one does not need to take a radical stance on completely avoiding branching. The hybrid strategy used in [24] and [27] performs route enumeration after solving each node. If a limit on the number of routes is reached, the enumeration is aborted and the BCP proceeds by traditional branching. Of course, since deeper nodes will have smaller gaps, at some point the enumeration will work.
The branching in our BCP is performed over sets \(S \subseteq V_+\), imposing the disjunction \((\sum _{a \in \delta ^(S)} x_a = 1) \vee (\sum _{a \in \delta ^(S)} x_a \ge 2)\). Those branching constraints are robust and can be translated into arc reduced cuts for the pricing in both child nodes. The BCP in [12] adopted a similar branching over sets (already used in [20]). In order to better choose the branching set, that BCP used strong branching. Each set in a collection containing from 5 to 10 candidate sets was heuristically evaluated by applying a small number of column generation iterations in its child nodes. Remark that the exact evaluation of each candidate, performing full column generation (perhaps also cut generation) in both child nodes, would be too expensive.

The simpler branching over individual arcs was used. The procedure starts by performing a quick evaluation of 30 candidate arcs, producing a ranking. The best ranked candidate is then fully evaluated and becomes the incumbent winner. Then, other candidates with good ranking are better evaluated, but only while they have a reasonable chance of beating the incumbent winner.

It is possible to collect statistics along the enumeration tree to help on choosing the candidates. The previous evaluations of an arc are good predictors of future evaluations.

The phase zero performs the first selection of candidate sets. In the root node, this is a collection of \(\min \{n,300\}\) sets, chosen by the proximity of \(\sum _{a \in \delta ^(S)} \bar{x}_a\) to 1.5 in the current fractional solution. For a nonroot node v, the collection has cardinality between 50 and 10, depending on TS(v), the estimative of the size of the subtree rooted in v. Half of the candidates are chosen based on the history of previous calls to the strong branching procedure. In contrast, the choice of the remaining candidates favors fresh sets, that were never evaluated before.

The phase one performs a rough evaluation of each candidate by solving the current restricted Master LP twice, adding the constraint corresponding to each child node. Column and cut generation are not performed. The resulting improvements in the lower bounds are usually overvaluations of the true improvements if that candidate is selected. The candidates are ranked by the product rule [1] and the best (between 20 and 3) candidates go to phase two. If TS(v) is very small, Phase 2 is skipped and the branching is performed with the best candidate of Phase 1.

Phase two performs quite precise evaluations. Column and cut generation are performed, the only difference to the standard solving is that only heuristic pricing is used. Actually, if TS(v) is large, even the exact pricing may be called. The results of Phase 2 are not only used to select the candidate to perform the current branching, they are stored in tables (the branching history) for subsequent use in the phase zero.
As mentioned before, our BCP uses a hybrid strategy. Enumeration is tried after solving each node. However, the strong branching can still be performed after a successful enumeration. This happens when the final set of routes R is too large (we use 20,000 as the limit) for the MIP solver. Of course, in both children of an enumerated node the pricing will continue to be done by inspection in the pool.
6 Computational experiments
Our BCP was coded in C++, IBM ILOG CPLEX Optimizer 12.5 was used as the LP solver and MIP solver in the exact method, the CVRPSEP package [19] was used to separate Rounded Capacity Cuts and Strengthened Combs, and routines from [33] were used to separate generic Clique Cuts after enumeration. The experiments were conducted in a single core of an Intel Xeon CPU E52667 v2 3.30 GHz with 264 GB RAM running CentOs Linux. We report results over the standard classes of instances (A, B, E, F, M, and P) used for testing exact methods for the CVRP. Since larger instances came into reach of the proposed BCP, results are also reported over other instances with up to 360 customers proposed in literature. All instances used in this paper are available in the CVRPLIB website (http://vrp.atdlab.inf.pucrio.br/).
Comparison of recent algorithms on series A, B, E, F, M, and P
Class  NP  LLE04  FLL\(+\)06  BCM08  BMR11  

Opt  Gap  T(s)  Opt  Gap  T(s)  Opt  Gap  T(s)  Opt  Gap  T(s)  
A  22  15  2.06  6638  22  0.81  1961  22  0.2  118  22  0.13  30 
B  20  19  0.61  8178  20  0.47  4763  20  0.16  417  20  0.06  67 
EM  12  3  2.10  39592  9  1.19  126987  8  0.69  1025  9  0.49  303 
F  3  3  0.06  1046  3  0.14  2398  2  0.11  164  
P  24  16  2.26  11219  24  0.76  2892  22  0.28  187  24  0.23  85 
Total  81  56  78  72  77  
Processor  Celeron 700 MHz (?)  Pent. 4 2.4 GHz (561)  Pent. 4 2.6 GHz (624)  X7350 2.93 GHz (1108) 
Class  NP  Con12  CM14  Rop12  BCP  

Opt  Gap  T(s)  Opt  Gap  T(s)  Opt  Gap  T(s)  Opt  Gap  T(s)  
A  22  22  0.07  59  22  0.09  59  22  0.57  53  22  0.36  2.24 
B  20  20  0.05  89  20  0.08  34  20  0.25  208  20  0.14  6.87 
EM  12  10  0.30  2807  10  0.27  1548  10  0.96  44295  12  0.33  2712 
F  3  2  0.06  3  3  0.03  27722  3  0.25  2163  3  0.00  3183 
P  24  24  0.13  43  24  0.18  240  24  0.69  280  24  0.42  21.3 
Total  81  78  79  79  81  
Processor  E5462 2.8 GHz (1204)  E5462 2.8 GHz (1204)  i72620M 2.7 GHz (1563)  E52667 3.3 GHz (1996) 
Detailed results over selected instances
Instance  Algo  IUB  RLB1  RLB2  RT(s)  FLB  Nds  TT(s) 

Mn151k12  BMR11  1015  1004.3  –  380  1004.3  1  380 
Con12  1015  1008.9  1012.5  19041  1015  1  19699  
Rop12  1015  1001.5  –  1015  5268  417146  
CM14  1015  1011.2  1012.6  9942  1015  1  10110  
BCP  1015  1011.2  1013.0  180  1015  1  186  
Mn200k16  BMR11  1256.6  –  319  1256.6  1  319  
Con12  1278  1263.0  –  265589  1263.0  1  265589  
Rop12  1278  1253.0  –  1258.2  106  7200  
CM14  1278  1266.9  –  432000  1266.9  1  432000  
BCP  1278  1266.6  –  807  1274  75  28620  
Mn200k17  BMR11  1275  1258.7  –  436  1258.7  1  436 
Con12  1275  1265.1  –  34351  1265.1  1  34351  
Rop12  1276  1255.3  –  1261.4  144  7200  
CM14  1275  1269.2  –  432000  1269.2  1  432000  
BCP  1275  1268.8  –  695  1275  7  3479  
C4 (150)  BCP  1028.42  1025.0  1026.4  565  1028.42  3  1117 
C5 (199)  BCP  1291.29  1284.62  –  904  1291.29  57  22090 
G17 (240)  BCP  707.76  705.01  –  345  707.76  15  14693 
G13 (252)  BCP  857.19  851.93  –  4803  851.93  1  4803 
G9 (255)  BCP  579.71  576.86  –  9013  576.86  1  9013 
G18 (300)  BCP  995.13  993.22  –  381  995.13  23  13769 
G14 (320)  BCP  1080.55  1076.10  –  8124  1080.55  1175  \(\approx \)39 days 
G10 (323)  BCP  736.26  731.28  –  25689  731.28  1  25689 
G19 (360)  BCP  1365.60  1362.76  –  467  1365.60  339  162405 
The new BCP algorithm has a good performance and could solve all those 81 instances to optimality. On instance Mn200k16, it showed that the previous best known solution was not optimal. We should remark that instances Fn72k4, Pn101k4, and Fn135k7 are still better solved by a branchandcut algorithm, like [20]. As in [12], we could have used a hybrid method that is able to automatically switch to a branchandcut after severe problems with column generation convergence are found. However, in order to stick to the BCP paradigm, we prefer to report the results of a version where convergence problems triggers a dual stabilization strategy, similar to the one described in [25]. In fact, without dual stabilization Fn135k7 can not be solved in reasonable time.
Table 2 presents detailed information on the resolution of a selected set of larger instances. Besides Mn151k12, Mn200k16, and Mn200k17, it includes results on two instances from [6] and seven instances from [14]. In those cases, the number of customers is displayed in parenthesis. For each instance and method, column IUB presents the initial upper bound used by the method. Columns RLB1, ER1, RLB2, ER2, RT(s) are root node information. They are the lower bound obtained before enumeration (RLB1), the number of routes enumerated (if the method performs it and if the enumeration succeeds), (ER1), the improved root node lower bound after route enumeration, obtained by adding additional nonrobust cuts (if Contardo style enumeration is performed) (RLB2), the number of remaining enumerated routes after that (ER2) and the total root node computing time (RT(s)). The final lower bound given by FLB, which is in bold when optimal, the number of nodes in the search tree denoted by Nds and the total computational time in seconds TT(s) complete the table columns. Detailed results over each individual instance and the description of additional mechanisms to detect and exploit the symmetry present in the instances G9, G10, G13, G14, G17, G18, and G19 are provided in the appendix.
7 Conclusions

The separation of nonrobust cuts should be as much integrated with the pricing as possible. More precisely, besides taking classical polyhedral considerations into account, the nonrobust cuts should be designed in order to minimize their impact on the specific kind of algorithm used in the pricing. In the BCP presented in this paper, the limited memory SRCs has a quite odd algorithmic definition that only makes sense in the context of the labeling algorithm. For example, suppose an alternative BCP for the CVRP where a MIP model is used to price elementary routes. The limited memory SRCs would not fit in that algorithm, they would probably cause more negative impact in the pricing than ordinary SRCs.

When designing nonrobust cuts, it is desirable to have a parameter that allows a smooth control on cut strength vs impact in the pricing. In the case of limited memory SRCs, the parameter M has that role.

Even if designed and separated in a careful way, at some point the nonrobust cuts can indeed make the pricing intractable, halting the BCP algorithm. Therefore, it is advisable to have suitable escape mechanisms, like the rollback introduced in this work.

Fixing variables from the original formulation by reduced costs can help a lot. But this fixing can be more effective if the original formulation is chosen in order to match the algorithm using in the pricing. In fact, in the arcload formulation, the vertices in \(V_Q\) have a onetoone correspondence with the buckets in the labeling algorithm.

The idea of finishing a BCP by enumerating all columns that may be part of the optimal solution into a pool and perform pricing by inspection after that and eventually sending a much reduced problem to a MIP solver can be quite effective in some instances. However, for consistency reasons, it should be hybridized with traditional branching.

Strong branching is now a standard technique for improving branchandbound or branchandcut performance. Our experience confirms the statement by [32] that it can also improve a lot the performance of BCP algorithms.
References
 1.Achterberg, T.: Constraint integer programming. PhD thesis, Technische Universitat Berlin (2007)Google Scholar
 2.Baldacci, R., Christofides, N., Mingozzi, A.: An exact algorithm for the vehicle routing problem based on the set partitioning formulation with additional cuts. Math. Program. 115(2), 351–385 (2008)MathSciNetCrossRefMATHGoogle Scholar
 3.Baldacci, R., Mingozzi, A., Roberti, R.: New route relaxation and pricing strategies for the vehicle routing problem. Oper. Res. 59(5), 1269–1283 (2011)MathSciNetCrossRefMATHGoogle Scholar
 4.Boland, N., Dethridge, J., Dumitrescu, I.: Accelerated label setting algorithms for the elementary resource constrained shortest path problem. Oper. Res. Lett. 34(1), 58–68 (2006)MathSciNetCrossRefMATHGoogle Scholar
 5.Christofides, N., Eilon, S.: An algorithm for the vehicledispatching problem. Oper. Res. Q. 20, 309–318 (1969)CrossRefGoogle Scholar
 6.Christofides, N., Mingozzi, A., Toth, P.: The vehicle routing problem. In: Christofides, N., Mingozzi, A., Toth, P., Sandi, C. (eds.) Combinatorial Optimization, pp. 315–338. Wiley Interscience, New York (1979)Google Scholar
 7.Christofides, N., Mingozzi, A., Toth, P.: Exact algorithms for the vehicle routing problem, based on spanning tree and shortest path relaxations. Math. Program. 20, 255–282 (1981)MathSciNetCrossRefMATHGoogle Scholar
 8.Contardo, C.: A new exact algorithm for the multidepot vehicle routing problem under capacity and route length constraints. Technical report, ArchipelUQAM 5078, Université du Québec à Montréal, Canada (2012)Google Scholar
 9.Contardo, C., Martinelli, R.: A new exact algorithm for the multidepot vehicle routing problem under capacity and route length constraints. Discrete Optim. 12, 129–146 (2014)MathSciNetCrossRefMATHGoogle Scholar
 10.Dantzig, G., Ramser, J.: The truck dispatching problem. Manag. Sci. 6(1), 80–91 (1959)MathSciNetCrossRefMATHGoogle Scholar
 11.Desrochers, M., Desrosiers, J., Solomon, M.: A new optimization algorithm for the vehicle routing problem with time windows. Oper. Res. 40, 342–354 (1992)MathSciNetCrossRefMATHGoogle Scholar
 12.Fukasawa, R., Longo, H., Lysgaard, J., Poggi de Aragão, M., Reis, M., Uchoa, E., Werneck, R.F.: Robust branchandcutandprice for the capacitated vehicle routing problem. Math. Program. 106(3), 491–511 (2006)MathSciNetCrossRefMATHGoogle Scholar
 13.Godinho, M.T., Gouveia, L., Magnanti, T., Pesneau, P., Pires, J.: On timedependent models for unit demand vehicle routing problems. In: International Network Optimization Conference (INOC) (2007)Google Scholar
 14.Golden, B., Wasil, E., Kelly, J., Chao, I.: The impact of metaheuristics on solving the vehicle routing problem: algorithms, problem sets, and computational results. In: Fleet Management and Logistics, pp. 33–56. Springer, Berlin (1998)Google Scholar
 15.Irnich, S., Desaulniers, G., Desrosiers, J., Hadjar, A.: Pathreduced costs for eliminating arcs in routing and scheduling. INFORMS J. Comput. 22(2), 297–313 (2010)MathSciNetCrossRefMATHGoogle Scholar
 16.Irnich, S., Villeneuve, D.: The shortestpath problem with resource constraints and kcycle elimination for k \(\ge \) 3. INFORMS J. Comput. 18(3), 391–406 (2006)MathSciNetCrossRefMATHGoogle Scholar
 17.Jepsen, M., Petersen, B., Spoorendonk, S., Pisinger, D.: Subsetrow inequalities applied to the vehiclerouting problem with time windows. Oper. Res. 56(2), 497–511 (2008)CrossRefMATHGoogle Scholar
 18.Kullmann, O.: Fundaments of branching heuristics. In: Biere, A., Heule, M., van Maaren, H., Walsh, T. (eds.) Handbook of Satisfiability, pp. 205–244. IOS Press, Amsterdam (2009)Google Scholar
 19.Lysgaard, J.: CVRPSEP: a package of separation routines for the capacitated vehicle routing problem. Aarhus School of Business, Department of Management Science and Logistics (2003)Google Scholar
 20.Lysgaard, J., Letchford, A., Eglese, R.: A new branchandcut algorithm for the capacitated vehicle routing problem. Math. Program. 100, 423–445 (2004)MathSciNetCrossRefMATHGoogle Scholar
 21.Martinelli, R., Pecin, D., Poggi, M.: Efficient elementary and restricted nonelementary route pricing. Eur. J. Oper. Res. 239, 102–111 (2014)MathSciNetCrossRefMATHGoogle Scholar
 22.Naddef, D., Rinaldi, G.: Branchandcut algorithms for the capacitated VRP, Chap. 3. In: Toth, P., Vigo, D. (eds.) The Vehicle Routing Problem, pp. 53–84. SIAM (2002)Google Scholar
 23.Pecin, D., Pessoa, A., Poggi, M., Uchoa, E.: Improved branchcutandprice for capacitated vehicle routing. In: Integer Programming and Combinatorial Optimization, pp. 393–403. Springer (2014)Google Scholar
 24.Pessoa, A., Poggi de Aragão, M., Uchoa, E.: Robust branchcutandprice algorithms for vehicle routing problems. In: Golden, B., Raghavan, S., Wasil, E. (eds.) The Vehicle Routing Problem: Latest Advances and New Challenges, pp. 297–325. Springer, Berlin (2008)CrossRefGoogle Scholar
 25.Pessoa, A., Sadykov, R., Uchoa, E., Vanderbeck, F.: Inout separation and column generation stabilization by dual price smoothing. In: Symposium on Experimental Algorithms, pp. 354–365. Springer (2013)Google Scholar
 26.Pessoa, A., Uchoa, E., Poggi de Aragão, M., Rodrigues, R.: Exact algorithm over an arctimeindexed formulation for parallel machine scheduling problems. Math. Program. Comput. 2(3–4), 259–290 (2010)MathSciNetCrossRefMATHGoogle Scholar
 27.Pessoa, A., Uchoa, E., Poggi de Aragão, M.: A robust branchcutandprice algorithm for the heterogeneous fleet vehicle routing problem. Networks 54(4), 167–177 (2009)MathSciNetCrossRefMATHGoogle Scholar
 28.Poggi de Aragão, M., Uchoa, E.: Integer program reformulation for robust branchandcutandprice. In: Wolsey, L. (ed.) Ann. Math. Program. Rio, pp. 56–61. Búzios, Brazil (2003)Google Scholar
 29.Poggi de Aragão, M., Uchoa, E.: New exact algorithms for the capacitated vehicle routing problem. In: Toth, P., Vigo, D. (eds.) Vehicle Routing: Problems, Methods, and Applications, pp. 59–86. SIAM (2014)Google Scholar
 30.Righini, G., Salani, M.: Symmetry helps: bounded bidirectional dynamic programming for the elementary shortest path problem with resource constraints. Discrete Optim. 3(3), 255–273 (2006)MathSciNetCrossRefMATHGoogle Scholar
 31.Righini, G., Salani, M.: New dynamic programming algorithms for the resource constrained elementary shortest path problem. Networks 51(3), 155–170 (2008)MathSciNetCrossRefMATHGoogle Scholar
 32.Røpke, S.: Branching decisions in branchandcutandprice algorithms for vehicle routing problems. Presentation in Column Generation (2012)Google Scholar
 33.Santos, H., Toffolo, T., Gomes, R., Ribas, S.: Integer programming techniques for the nurse rostering problem. Ann. Oper. Res. 239(1), 225–251 (2014)MathSciNetCrossRefMATHGoogle Scholar