Generalized local branching heuristics and the capacitated ring tree problem

Discrete Applied Mathematics (

)

–

Contents lists available at ScienceDirect

Discrete Applied Mathematics journal homepage: www.elsevier.com/locate/dam

Generalized local branching heuristics and the capacitated ring tree problem Alessandro Hill a, *, Stefan Voß b,c a b c

School of Business, Universidad Adolfo Ibáñez, Santiago, Chile Institute of Information Systems (IWI), University of Hamburg, Hamburg, Germany Escuela de Ingeniería Industrial, Pontificia Universidad Católica de Valparaíso, Valparaíso, Chile

article

info

Article history: Received 22 November 2016 Received in revised form 30 July 2017 Accepted 18 September 2017 Available online xxxx Keywords: Capacitated ring tree problem Local branching Mathematical programming Local search Network design Matheuristic

a b s t r a c t In this paper we present a heuristic framework that is based on mathematical programming to solve network design problems. Our techniques combine local branching with locally exact refinements. In an iterative strategy an existing solution is refined by sequentially solving restricted mixed integer programs (MIPs) to optimality. These are obtained from the master problem MIP by limiting the number of variable flips for structured subsets of the binary edge variables which are selected based on the underlying network cost structure. We introduce generalized local branching cuts which enforce the latter using two parameters at the same time: the number of considered variables and the number of allowed variable flips. Using this concept we develop an efficient algorithm for the capacitated ring tree problem (CRTP), a recent network design model for partially reliable capacitated networks that combines cycle and tree structures. Our implementation operates on top of an efficient branch and cut algorithm for the CRTP. The sets of refinement variables are deduced from single-ball network node clusters. We provide computational results and an extensive analysis of the algorithm for a set of literature instances. We show that the approach is capable of improving existing best results for the CRTP and outperforms the pure refinement or local branching approaches. © 2017 Elsevier B.V. All rights reserved.

1. Motivation and contribution Network design applications in telecommunications and transportation environments typically involve a large number of decision variables in suitable optimization models. Although exact algorithms are usually not applicable to medium and large size instances they have proven useful in heuristic frameworks, also referred to as matheuristics [19]. This class of heuristics combines mathematical programming concepts and classical (meta-)heuristic paradigms. Integer programming based refinement algorithms have been successfully applied to complex network optimization problems (e.g. [6,2,4,13,20]) as well as other classes of challenging combinatorial optimization problems (e.g. [19,16]). These methods typically incorporate an exact mathematical programming based approach that is applied to a local improvement model for an existing solution. They get more effective with increasing complexity of the underlying problem structure [2,13]. Due to the limited computational efficiency of the exact method that is used to carry out the refinements, the mentioned techniques are in fact only effective locally on small-sized substructures. Commonly, random, multi-start or contraction based perturbation mechanisms are added to (partially) overcome local optimality.

*

Corresponding author. E-mail address: [email protected] (A. Hill).

https://doi.org/10.1016/j.dam.2017.09.010 0166-218X/© 2017 Elsevier B.V. All rights reserved.

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

2

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

In this work we suggest an approach that aims at increasing the number of decisions considered for local refinement. This is achieved by bounding the scale of modification in terms of binary variable flips in return. The basic idea of considering neighboring solutions within a certain Hamming distance is known as local branching and has been introduced as a polishing procedure in general mixed integer programs (MIPs) in [8]. Several highly efficient heuristics for various combinatorial optimization problems successfully incorporate this concept (e.g. [21,18,22]). In [17], a refinement method for general binary MIPs is presented that is closely related to the relaxation induced neighborhood search method (RINS) [5]. Both approaches use information from the solution of the linear relaxation of the MIP to select variables and therewith define neighborhoods that are explored in an exact fashion. In contrast to these works, our approach does not use fractional solutions to guide the local search. It is solely based on the structural exploration of neighborhoods that are derived from the incumbent solution network and the underlying edge costs. The corresponding simultaneous combination of subsets of binary variables of different sizes with suitable Hamming bounds provides a complete algorithmic framework. We formalize the iterative construction of refinement models by describing new generalized local branching cuts which are added to the master program before solving these extended MIPs to optimality. Herewith, we are able to arbitrarily increase the local area that is considered for refinement by adequately limiting the allowed variable flips. We show that the sketched ideas can be turned into an effective algorithm for capacitated network design. More precisely, we devise an efficient heuristic for the capacitated ring tree problem (CRTP). The CRTP was introduced in an earlier paper of Hill and Voß [14]. It combines ring based models such as the classic traveling salesman problem (TSP) with tree based models such as the Steiner tree problem (STP) under capacity constraints. Heuristics and exact algorithms for the CRTP are discussed in [10,14] and [15]. A facility location variant of the problem is considered in [1] and algorithms for bi-objective reliabilityoriented variants are elaborated in [12]. Even though the CRTP can be broadly applied as it generalizes several prominent network design problems, our techniques can be transferred to related network design problems with reasonably low effort. More generally, we suggest that our main ideas can be used to solve a variety of discrete, or even (partially) continuous, optimization problems. The main contributions of this work are

• the development of a generic framework for heuristic network design based on a generalized local branching, combining local branching and integer programming based refinement techniques, and

• the design and analysis of an efficient heuristic algorithm for the CRTP incorporating these concepts which is able to find new best solutions for literature instances. Section 2 contains a formal description of the CRTP along with the MIP formulation used in our algorithm. After the presentation of the generic local branching based refinement technique in Section 3 we develop the heuristic algorithm for the CRTP in Section 4. In Section 5 we provide the improved results for literature instances and computationally compare different configurations of our method. We close the paper with conclusions in Section 6. 2. The capacitated ring tree problem In this section, we formally define the considered network design model, describe an application, and provide a mathematical model based on integer programming. 2.1. Problem definition The capacitated ring tree problem (CRTP) [14] generalizes several classical ring and tree based network design models. The base topology in a solution network is the ring tree, defined as a graph consisting of a cycle C and a set of node disjoint trees T , each of them intersecting with C in exactly one node. A ring tree reduces to a pure tree if |C | = 1, and to a cycle if T = ∅. To simplify our description, we say that a ring tree star, centered in d, is a graph obtained by a union of ring trees that intersect in d such that for each of these ring trees Q,

• d is a leaf in Q if Q is a pure tree, and • d is a cycle node of degree 2 in Q, otherwise. Fig. 1 depicts three characteristic ring tree stars. ˙ U2 , Steiner nodes W , a depot node d, and capacity bounds m, q ∈ N. In the CRTP, we are given customer nodes U = U1 ∪ ˙ W ∪{ ˙ d} and the set of potential edges between two nodes as E. Let ce be the given cost Denote the set of all nodes as V = U ∪ for the installation of an edge e ∈ E. A ring tree star N on nodes from V , centered in d, is a solution for the CRTP if (i) (ii) (iii) (iv)

each customer node in U is contained in N , each customer node in U2 is on a cycle in N , N is composed of at most m ring trees, and each ring tree in N contains at most q customers.

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

3

Fig. 1. Ring tree stars composed of 4 ring trees (left), 3 ring trees (center) and 5 ring trees (right).

Fig. 2. An optimal solution for instance 63 (q = 10, m = 3, |V | = 51, |U1 | = 13, |U2 | = 12, |W | = 25) implementing a ring tree star with 3 ring trees.

We refer to the set of nodes of a graph G by V [G ] and ∑ to its edges by E [G ]. Then the CRTP asks for a solution that minimizes the sum of the edge costs of the ring tree star N , i.e. e∈E [N ] ce . The CRTP is NP-hard as it reduces to the TSP in the case that all customers have to be on a ring (U1 = ∅), no Steiner nodes are given (W = ∅), and only one ring can be installed (m = 1, q = |U2 |). We say that nodes in U2 , also called type 2 nodes, correspond to customers of type 2, whereas nodes in U1 are of type 1 and correspond to type 1 customers. Type 1 nodes have to be connected to d by at least one path while type 2 nodes have to be connected to d by exactly two node disjoint paths. The cycles in N are also called rings. By requiring the type 2 nodes to be part of such rings we provide additional reliability to the corresponding customers: there are exactly two (node) disjoint paths from such nodes to d. This double-connectivity is optional for the remaining type 1 nodes, and the Steiner nodes in W are not even required to be nodes in N unless beneficial regarding the overall network cost. A solution for the CRTP is illustrated by Fig. 2. 2.2. Application The CRTP is a recent bi-level network optimization problem that finds application in the design of transportation networks as well as telecommunication networks (see also [11]). A typical application is the planning of last-mile telecommunication technology, which connects customers via optic fiber-based lines to a central distributor, providing access to the backbone network. Strategically important consumers such as, e.g., hospitals or police stations are equipped with increased reliability by installing a redundant connection. To this end, cycle structures are commonly used. Using the CRTP, the distributor is modeled by the depot d, and every critical customer is declared of type 2 whereas remaining households are represented by customer nodes of type 1. Steiner nodes are used to model optional intermediate network nodes such as, e.g., street or duct crossings. Capacity restrictions arise from technological limitations at the distributor. 2.3. Mathematical model The following non-compact MIP formulation (F) was developed in [14]. It is based on a directed Steiner tree problem formulation in which rings are enforced by circulations. We observe that removing one center-incident edge in each ring turns a ring tree star into a tree. This tree can be transformed into a directed tree by rooting it in the center d and replacing the edges by arcs such that each leaf node can be reached from d via a directed path. A directed cycle can be formed in the directed network by the insertion of an arc towards d. To ensure that each type 2 node is on such a directed cycle we require Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

4

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

a circulation to pass through them and d for each ring. Such a directed network induces a solution for the CRTP obtained by replacing arcs by edges. We denote the set of potential arcs as A and arcs leaving [entering] a node set S are denoted by δ + (S) [δ − (S)]. U(S) is the set of all customer nodes in node set S. A binary arc variable xa is introduced for each arc a ∈ A, which takes value 1 if a is installed in the solution and value 0 otherwise. Moreover, we explicitly encode the usage of each edge e ∈ E by a binary edge variable ye which takes value 1 if e is installed and value 0 otherwise. The circulation on an arc is modeled by a continuous arc circulation flow variable fa which will have value 0 if a is a tree edge in the network and value 1 if a is part of a directed cycle. (F)

min

∑

ce ye

(1)

e∈E

∑

s. t .

xa ≥

|U(S)| q

a∈δ − (S)

∑

∀ S ⊂ V \ d,

(2)

xa = 1 ∀ i ∈ U ,

(3)

xa ≤ 1 ∀ i ∈ W ,

(4)

xa ≤ m,

(5)

a∈δ − ({i})

∑ a∈δ − ({i})

∑ a∈δ + ({d})

xij + xji = yij ∀ {i, j} ∈ E ,

∑

fa =

∑

fa ∀ i ∈ V ,

a∈δ − ({i})

a∈δ + (i)

∑

fa = 1 ∀ i ∈ U2 ,

(6) (7)

(8)

a∈δ − ({i})

0 ≤ fa ≤ xa ∀ (i, j) ∈ A,

(9)

xa ∈ {0, 1} ∀ a ∈ A,

(10)

ye ∈ {0, 1} ∀ e ∈ E .

(11)

Assignment constraints (3) ensure an in-degree equal to one for each customer, whereas constraints (4) limit the inbound arcs to one for each Steiner node. The capacitated connectivity constraints (2) bound the number of customers per ring tree to q. These exponentially many constraints are separated dynamically during the branch and bound procedure presented in [14]. We enforce the underlying circulation by (in)equalities (7), (8) and (9). Since we consider directed ring tree stars, inequality (5) is sufficient to limit the number of ring trees to m. To obtain a simple undirected solution network and identify its edges we implement the variable linking equalities (6). For a more detailed discussion of this formulation we refer to Hill and Voß [14]. 3. Generalized local branching In this section we describe our generic framework. The specific application of our techniques to the CRTP follows in Section 4. Since we mainly use integer programming techniques we give descriptions using terminology and concepts from mathematical programming, in particular, a branch and bound framework. We assume that we have a MIP formulation at hand in which the network structure is encoded by binary edge variables. The presented techniques can be adapted to different mathematical programming approaches and, moreover, to related network design problems. Therefore, we consider a generic MIP (P) min c T y, Ay ≤ b, y ∈ {0, 1}|E | ,

(12)

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

5

with ye being the variable taking value 1 if the edge e ∈ E is installed in the solution network, 0 otherwise. Without loss of generality, we omit eventual continuous variables in (P) for the sake of a simplified description. The constraints in (12) describe the integer feasible solutions as a subset of the fractional solutions contained in the polyhedron Γ described by Ay′ ≤ b, y′ ∈ R|E | . A cut for (P) is an inequality that describes a halfspace in R|E | whose intersection with Γ is non-trivial. Moreover, we assume that we are given a feasible reference solution y˜ for (P), as illustrated in Fig. 3 (left), which represents a solution network Ny˜ . We reformulate the concepts of local branching and integer programming based refinements in Sections 3.1 and 3.2, respectively, before we bring them together in Section 3.3. Finally, we describe the introduced cuts on the unit cube in Section 3.4. 3.1. Local branching Local branching (LB) was introduced by Fischetti and Lodi in [8] as a polishing heuristic for a general purpose MIP solver. It is applied whenever an integer feasible solution y˜ is found in the branch and bound algorithm that replaces the current incumbent. To carry out the local search a restricted MIP is solved that is obtained by adding a local branching cut to the master problem. For k ∈ N0 such an inequality

∑

∑

(1 − ye ) +

e∈E :˜ye =1

ye ≤ k

(13)

e∈E :˜ye =0

induces a k-opt neighborhood N(y˜ , k) of y˜ . It contains each feasible solution y for (P) within Hamming distance ∆(y˜ , y) = |{e ∈ E : y˜ e ̸ = ye }| ≤ k from y˜ . Fig. 3 (center) illustrates N(y˜ , k) in a branching scheme for k = 2. This technique found its way into commercial solvers such as CPLEX. Inverse local branching cuts can be obtained by reversing the sense of (13) but turned out to be less effective in practice. A related concept in the heuristic literature is limited discrepancy search (LDS) [9], in which the decision tree is also traversed respecting a bound on the deviation from a reference solution. Compared to LB, LDS does not necessarily take place in an exact mathematical programming environment and is rather constraint satisfaction oriented in its original version. 3.2. Refinement techniques The exploration of neighborhoods of y˜ by exact methods is likewise the key ingredient for MIP refinement techniques. In contrast to the LB idea in Section 3.1 it focuses on the re-optimization of a subset of decision variables without bounding ∆(y˜ , y) for a neighboring solution y. In terms of mathematical programming this idea can be translated to variable fixing of the remaining variables. However, variable fixing techniques typically use information from solutions of the linear relaxed problem to deduce integer feasible solutions (e.g. [5,3]). Related approaches that round fractional solutions to integers are used to find an integer feasible solution at all (e.g. [7]). Additionally, structural knowledge about the underlying optimization problem is usually exploited in problem specific branch and bound algorithms. For the network Ny˜ we can fix the current state of edges F ⊆ E by adding the following variable fixing equalities to (P).

{ ye =

0 if 1 if

e ̸ ∈ E [Ny˜ ] e ∈ E [Ny˜ ]

∀ e ∈ F.

(14)

This defines the neighborhood N(y˜ , F ) containing all the feasible solutions in (P) such that a variable ye that corresponds to an edge e ∈ F is forced to 1 if e is installed in N and to 0 otherwise. The remaining edge variables (for edges in E \ F ) are free to take any constraint-feasible value in {0, 1}. Fig. 3 (right) depicts three solutions in N(y˜ , F ) for F = {e0 , e3 , . . . , en }, represented in a branch and bound tree. These solutions are obtained from the reference solution y˜ (Fig. 3, left) by fixing the values of the variables corresponding to edges in F and considering all globally feasible value combinations for the variables corresponding to remaining edges in E \ F = {e1 , e2 }. 3.3. Combining local branching and refinements In this section we generalize the concepts of local branching and MIP refinements to obtain the generic concept of generalized local branching (GLB). To develop the latter we first observe that the refinement techniques described above can be formulated as local branching on a 2-partition of the edge set: the fixed edges and the flexible ones. Again, let F ⊆ E be the set of edges that should be fixed to their current values in y˜ and let E \ F contain the remaining edges whose variables are considered for refinement. Then we can achieve this by the addition of two partial local branching cuts. The first one defines the trivial neighborhood N(y˜ F , 0) restricted to the edges in F . The second one corresponds to all the feasible solutions N(y˜ E \F , |E |). More generally, let F = (F1 , . . . , Fp ) be a cover of the edge set E. Then we apply individual Hamming bounds p K = (k1 , . . . , kp ) ∈ N0 to the corresponding variable subsets. Hereby we can incorporate pre-knowledge about how many changes we expect after sub-optimizing each set Fi . We define generalized local branching cuts as a system of LB cuts

∑ e∈Fi :˜ye =1

(1 − ye ) +

∑

ye ≤ ki ∀ i ∈ {1, . . . , p}.

(15)

e∈Fi :˜ye =0

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

6

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

Fig. 3. A solution y˜ of (P) in a branch and bound tree (left), five solutions in N(y˜ , 2) (center) and three solutions in N(y˜ , F ) with F = {e0 , e3 , . . . , en } (right).

For each edge set Fi we limit the number of variable flips among the corresponding edge variables by the constant ki . In particular, if ki = 0 then the part of the current solution Ny˜ represented by Fi is fixed. ki ≥ |E | means that the partial solution is considered for full refinement. We denote the corresponding neighborhood by N(y˜ , F , K). We refer to (P) extended by GLB cuts (15) as the generalized local branching problem (GLBP) corresponding to F and K. Note that this concept is related to the concept of defining corridors within the corridor method [23]. However, the latter attempts to increase the set of decisions that is considered for refinement depending on the optimization method at hand, whereas our approach is designed to work on arbitrary subnetworks, in presence of the Hamming bounds, though. Following the approach in [8] we can define inverse generalized local branching cuts for F and K as inequalities (15) with flipped signs which we will not further investigate in this work. So far, we did not address strategies to set up suitable edge set and Hamming bound parameterizations given by F and K. In Section 4 we focus on the CRTP and present a practical implementation of these concepts. The described GLB cuts can then also be integrated in an exact algorithm as it was originally suggested for LB in [8]. As common for exact algorithms, the branch and cut method for the CRTP that we use in the next section already incorporates such a polishing, based on CRTP-specific local search [10]. However, we consider the pure improvement heuristic in this work which is embeddable in arbitrary algorithmic frameworks. 3.4. GLB cuts on the unit cube In the following we discuss the geometric interpretation of the GLB cuts introduced above using the unit cube. Let Φ be the convex hull of the integer points in Γ . We recall that cuts used to accelerate cutting plane algorithms (e.g. disjunctive, cover, Gomory mixed integer) tighten Γ to describe Φ . In contrast to these techniques, the GLB cuts aim at cutting off integer-feasible solutions from Φ , regardless of the resulting linear programming relaxation. In other words, the number of feasible solutions is reduced in order to obtain a problem that is computationally tractable. However, the mentioned cutting plane techniques, together with problem specific ones, play an important role when solving the reduced GLBPs within the overall algorithm in Section 4. GLB cuts are in general not facet defining. To see this, consider an edge variable based formulation for the symmetric TSP on n > 3 nodes and m = n(n − 1)/2 edges. Let 1, . . . , n be a customer sequence, also called a tour, which represents the current reference solution. Furthermore, let y1 , . . . , yn be the corresponding edge variables that represent the tour, ordered according to the tour sequence. We consider GLB parameters F0 = ({y1 , y3 , yn+1 , . . . , ym }, {y2 , y4 , . . . , yn }) and K0 = (3, 0). Then the GLB cuts obtained through F0 and K0 allow up to three variable flips for the variables that correspond to the non-incident tour edges y1 and y3 as well as all unused edges. Certainly, no feasible solution can be obtained by removing either one of these tour edges while adding two unused edges. At the same time, the elimination of y1 and y3 cannot be repaired by a single edge insertion. Only the augmentation of the first Hamming bound to 4 would lead to facet-defining cuts and a non-trivial neighborhood. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

7

Fig. 4. Three GLB cuts with respect to reference solution y˜ = [0, 0, 0].

Fig. 5. Three GLB search spaces with respect to reference solution y˜ .

In the following example in {0, 1}3 let y˜ = [0, 0, 0] be a reference solution. For the sake of simplicity we assume that Φ = {0, 1}3 . Although the purpose of this setting is to better understand the GLB cuts, it could be a model for a pricecollecting spanning tree problem on three nodes. We limit ourselves to GLB cuts with p = 2 to avoid trivial cuts. For F1 = {y1 }, F2 = {y2 , y3 } and k1 = 0, k2 = 1 let F1 = (F1 , F2 ) and K1 = (k1 , k2 ). Then we construct the following GLB cuts according to (15). y1 ≤ 0 , y2 + y3 ≤ 1.

(16)

We denote the corresponding hyperplanes by H1 and H2 . These cuts reduce Φ to the convex hull of N(y˜ , F1 , K1 ) projected onto H1 . As shown in Fig. 4 (left), the resulting triangle-shaped linear search space is spanned by the integer-feasible solutions y˜ , [0, 1, 0] and [0, 0, 1]. To see the effect of the chosen Hamming bounds, let us first consider k′2 = 0 and the corresponding hyperplane H2′ . Fig. 4 (center) shows the resulting trivial neighborhood containing y˜ only. Conversely, if k′′2 = 2 then the resulting hyperplane H2′′ does not cut off any points in Φ and all the four integer solutions in Φ ∩ H1 are considered. The latter corresponds to a MIP refinement search as described in Section 3.2. Using k2 we can explore all the points within Hamming distance one to y˜ by rearranging F1 . This can be achieved by the variable partitions F1 , ({y3 }, {y1 , y2 }) and ({y2 }, {y1 , y3 }). The resulting neighborhoods are illustrated in Fig. 5. The exploration of these three search spaces is inefficient from a computational point of view due to notable redundancy regarding integer points. The three integer feasible solutions appear as potential improved solutions six times in total. Alternatively, Φ can be reduced to the corresponding simplex by the pure LB cut y1 + y2 + y3 ≤ 1 which can be expressed as a GLB cut with F = ({y1 , y2 , y3 }) and K = (1). Furthermore, the union of the subspaces depicted in Fig. 5 does not cover Φ . In order to take into account all integer solutions, let us now alter the Hamming bound for the first variable set F1 . Since |F1 | = 1 we only consider the incremented value, i.e. k′1 = 1. Fig. 6 illustrates the effect on Φ using k2 (left), k′2 (center) and k′′2 (right). It can be seen that the corresponding hyperplane H1′ does not cut off any integer points. Therefore, this parameterization corresponds to pure local branching as described in Section 3.1. By definition, GLB cuts can be parameterized for a given variable partition F to induce all subspaces of Φ that contain integer points within Hamming distance ki with respect to Fi for each 1 ≤ i ≤ p; in particular, the reference solution y˜ . For the Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

8

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

Fig. 6. Three GLB cuts with respect to reference solution yˆ .

Fig. 7. Two single-ball clusters BN (v, 6) and BN (u, 4).

example above, eight configurations exist for the 3-partition of the variable set (k1 , k2 , k3 ∈ {0, 1}), eighteen for the three 2-partitions (k1 ∈ {0, 1}, k2 ∈ {0, 1, 2} or k1 ∈ {0, 1, 2}, k2 ∈ {0, 1}) and four for the 1-partition (k1 ∈ {0, 1, 2, 3}). This results in eleven (=1+3+3+3+1) distinct neighborhoods for a fixed y˜ . In Section 4 we propose a strategy to explore such neighborhoods effectively for the CRTP. 4. A generalized local branching algorithm for the CRTP We first describe single-ball node clustering techniques that will serve to build effective GLB cuts in Section 4.1. The CRTP tailored GLB techniques are presented in Section 4.2. We explain characteristics of the underlying exact mathematical programming approach to be taken into account, such as cut management, in Section 4.3. This section is closed by the overall strategy in Section 4.4. 4.1. Single-ball clusters In general local search algorithms the exploration of multiple suitable diverse neighborhoods is known to be effective, as shown for the CRTP in [10]. To study the strength of our GLB cuts, in this work we will limit ourselves to simple but effective ball type neighborhoods of a reference network N . In several variants, these were already successfully implemented in MIP refinement techniques in [13]. Hence, we use the following node clustering strategy to generate structured 2-partitions of the edge variables needed to deduce GLB cuts. For a cluster center node v ∈ V [N ] and r ∈ {2, . . . , |V [N ]|}, we define a (single-)ball cluster BN (v, r) ⊆ V [N ] as the set containing v and the r − 1 closest nodes to v with respect to the distance function c. Two such balls are given in Fig. 7. For the overall effectiveness of the GLBPs the selection of the ball cluster centers is crucial. To locally optimize the current solution N evenly, we build ball node clusters for well distributed cluster centers in order to cover the whole network. Starting with a cluster center node of highest cumulative distance to the remaining nodes, we iteratively choose the next cluster center by adding the most remote node with respect to the previously selected ones. We build a cluster BN (v, r) for each hereby obtained node v and a suitable r. The edges incident to the depot are of particular importance since they are closely related to the number of installed ring trees. Moreover, the opening and closure of ring trees is facilitated by these edges. It turned out to be beneficial to include d in each ball. For a very large relative number of Steiner nodes it could be convenient to limit their inclusion which was not necessary in our experiments. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

9

Fig. 8. Cylindrical illustration of two different single-ball GLB cuts with r1 = |B1 | = 34 and r2 = |B2 | = 6, and Hamming bounds k1 and k2 , each of them (and both together) inducing a GLBP for the solution N .

4.2. Generalized local branching cuts for the CRTP We now use the idea of GLB cuts from Section 3.3 to construct GLBPs based on the single-ball clusters described in Section 4.1. For such a cluster B ⊆ V [N ] let IE [B] be the set of edges in E with both end nodes in B. Then we add GLB cuts (15) for the induced edge partition FB = (IE [B], E \ IE [B])

and Hamming bounds K = (k, 0).

We parameterize the GLBPs by the cluster size and the Hamming bound k as follows. Assume that we know an estimate r for the largest computing machine dependent cluster size such that the pure refinement problem can be solved efficiently by our exact method. In practice, r can be determined by a calibration mechanism in which, for a sufficiently large k, a cluster is incrementally increased as long as the corresponding GLBP can be solved within a reasonable time limit. Contrary, let r be the estimated largest cluster size such that the GLBP for a small non-trivial k can be solved efficiently. r can be obtained by a similar procedure as used for r. We say a GLB scheme of order m is a sequence of pairs (r1 , k1 ), . . . , (rm , km ) used to construct GLBPs with |B| = ri and Hamming bound ki for i ∈ {1, . . . , m}. The scheme that we use in our algorithm arises from linear interpolation with respect to (r , k) and (r , k). More precisely, we use a step size ρ to define the cluster sizes r , r +ρ, . . . , r. The Hamming bounds are set to k, k − κ, . . . , k where κ = ρ (k − k)/(r − r). Here we presume that increasing the complexity of the GLBP by enlarging the set of cluster nodes B, and therewith the set of flexible variables IE [B], can be compensated by the reduction of the number of allowed variable flips k, which turned out to be suitable for our approach. Certainly, r and r are sensitive to the hardness of the instance and the chosen balls. In particular, the capacity bounds m and q, the customer type ratio |U1 ∩ B|/|B| and the Steiner node portion |W ∩ B|/|B| in B can have an impact on the performance of the exact method. In Fig. 8 we illustrate two GLB cuts using a cylindrical representation of the GLBP solution spaces in terms of k and r = |B|. 4.3. The underlying branch and cut method We use the branch and cut method presented in [14] as underlying mathematical programming based algorithm. When running the method including the GLB cuts some formulation-specific characteristics need to be considered. As typical for branch and cut algorithms the cut management plays an important role for the efficiency and the stability of the method. Model cuts as well as valid cuts added at the root node are indispensable to obtain strong lower bounds. However, their separation can be time consuming. To avoid the repeated generation of such master problem root cuts in each GLBP we pre-compute these in an initialization phase and add them to each model. We add all the maximally violated cuts that are identified in multiple rounds of solving the root node relaxation, which does not cause any memory issues in our experiments. Moreover, it turns out to be advantageous to continuously extend this set of inequalities by the cuts separated within the GLBPs. Unfortunately, the found solver-internal cuts cannot be accessed and eventually have to be re-calculated dynamically. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

10

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

Fig. 9. An infeasible structure due to missing ring enforcing circulation constraints.

We provide the current incumbent solution to the branch and cut method each time it is called for solving a GLBP. The local search based polishing procedures to accelerate the branch and cut algorithm may return a solution that violates the current GLB cuts. Nonetheless, we update the current best solution in this case since it is feasible for the original problem. Assuming a metric edge cost function c, and therefore c satisfying the triangle inequality, the mathematical formulation for the CRTP does not need constraints enforcing a single directed path from each cycle node to the depot. However, these restrictions are necessary when performing GLB refinements. The partial fixing of a cycle structure in general forces the creation of non-ring-tree structures as shown in Fig. 9. 4.4. Overall strategy In this section we present the overall strategy used in the GLB heuristic. Basically, we refine an initial ring tree star N according to the GLB parameters (r , k) provided by a GLB scheme sorted by increasing cluster size r = |B|. Fig. 10 illustrates the relation of k and |B| in our algorithm. For a cluster size r and a Hamming bound k, Algorithm 1 locally optimizes N using the ball clustering strategy presented in Section 4.1 until no improvement can be found. Improvements are immediately incorporated in N . The function findSingleBallCenters(N , P) returns a set of customers used for the construction of ball clusters. The GLB cut for the refinement edge variables induced by a node set B and a Hamming bound k is returned by CutGLB (IE [B], k, N ). CutGLB (E \ IE [B], 0, N ) returns the GLB cut that fixes the remaining edge variables in the master MIP, denoted by F(P). We denote the MIP obtained by the addition of a cut R to F(P) by F(P) ⊕ R. A GLBP F is solved by the exact algorithm by calling the procedure solve(F) which either returns an improving solution or the incumbent. Algorithm 1 REFINE() Input: CRTP P, solution N , cluster node limit r, Hamming bound k; repeat cold ← c(N ); Z ← findSingleBallCenters(N , P); for all v ∈ Z do B ← BN (v, r); F ← F(P) ⊕ CutGLB (IE [B], k, N ); F ← F ⊕ CutGLB (E \ IE [B], 0, N ); N ← solve(F); end for until c(N ) = cold return N ; Algorithm 2 describes the main procedure including the construction of a start solution by generateStartSolution(P) and the calculation of the GLB scheme by generateSortedSchemeGLB(P).

5. Computational study In this section we provide computational results for literature instances and give a comprehensive analysis of the algorithm’s performance. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

11

Fig. 10. With an increasing ball size |B| we decrease k and the number of considered balls in our GLB scheme.

Algorithm 2 The GLB heuristic for the CRTP. Input: CRTP P; N ← generateStartSolution(P); H ← generateSortedSchemeGLB(P); while |H|> 0 do (r , k) ← pop(H); N ← REFINE(P,N ,r,k); end while

5.1. Instances We study our algorithm on 225 CRTP instances1 that were suggested for the CRTP in [14]. These instances contain up to 101 nodes (|V | = 101) and are deduced from the TSPlib instances eil51, eil76 and eil101. In a first step, δ % of the customer nodes in the TSP instance are randomly declared as Steiner, using δ ∈ {0, 25, 50, 75}. Instances with capacity m ∈ {3, 4, 5} are created, for which the ring tree customer capacity q is chosen such that the number of customers is about 90% of the overall customer capacity mq. Then type 1 customers are assigned randomly with rates in {0, 0.25, 0.5, 0.75, 1}. The remaining original customers are of type 2. For 102 instances no proven optimal solutions are known according to Hill and Voß [14]. 5.2. Framework, implementation and parameterization The algorithm is implemented in C++ using the CPLEX 12.6 MIP solver. Computations are done on an Intel i7-4610M 3.00 GHz processor unit with 16 GB RAM. To show the strength of our new strategy we consider the following four configurations. 1 The test set can be downloaded from http://dimacs11.cs.princeton.edu/downloads.html. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

12

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

(A) Heuristically enhanced GLB: the GLBPs are constructed for a pre-specified scheme; heuristic start solution Hill [10]; local search polishing of each improved solution found Hill [10]. (B) Self-contained GLB: the GLBPs are constructed for a pre-specified scheme; random start solution; no local search. (C) Pure refinement: the GLBPs are constructed for one ‘‘small’’ ball size only; k is set to the number of current ball edges; heuristic start solution Hill [10]. (D) Pure local branching: the GLBPs are constructed for one ‘‘large’’ ball size only; k is set to a small value; heuristic start solution Hill [10]. Our aim is to compare the GLB method [(A) and (B)] to special cases of the presented strategy [(C) and (D)] in order to show that the proposed integration yields superior results. We compare the solutions found by our approach to the best known results for the CRTP from the literature. Note, however, that we do not intend to benchmark with all available solver parameterizations. To solve the GLBPs we use the efficient branch and cut algorithm developed in [13] using a time limit of 120 s. This exact approach originally incorporates the heuristic techniques to construct start solutions and for solution polishing developed in [10]. Note that we use an improved version of the heuristic presented in [10]: each construction in the multi-start algorithm is repeated using a shortest path Steiner tree heuristic instead of the computation of the minimum spanning tree. To understand the impact of the latter, configuration (B) does not include these features. A random start solution is generated by randomly selecting type 2 customers to build rings at full capacity instead. The remaining type 1 customers are iteratively used to construct trees from ring nodes in a random fashion. This results in feasible networks of 1.2 to 6.5 times the cost of the best known solution (3.1 on average). Configurations (C) and (D) represent the pure refinement and LB introduced in Sections 3.1 and 3.2, respectively. In our experiments we set the step size for the cluster size ρ to 12. We determine a minimal cluster size r = 14 and a maximal cluster size r = min(62, |N˜ |) as suitable by a series of calibration runs. For the maximal and the minimal number of variable flips we use k = 14 and k = 4, respectively. The number of ball clusters constructed for a pair (r , k) is set to ⌊2.9|V [N ]|/r ⌋. Fig. 12 (left) shows the complete GLB scheme. To further strengthen the primal GLBP bounds we turn on the solver-internal polishing heuristics, including local branching. 5.3. Results Tables 1–3 contain the results obtained by our GLB method with configurations (A), (B), (C) and (D). The column information for each instance is explained as follows. P : CRTP instance id

|U| : overall number of customers µ : rate of type 1 customers (|U1 |/|U |) |W| : number of Steiner nodes m q c(N˜ ) c(N )

 # t

γ

θ

: depot ring tree capacity : ring tree customer capacity : start solution costs : costs computed by the GLB configuration : number of considered GLBPs (MIPs) : number of refinements : GLB runtime in seconds : best achieved relative cost improvement in % with respect to the solution cost α computed by the heuristic in [10]: (α − c(N ))/α : relative reduction of the optimality gap2 ub − lb in %; 100(ub − c(N ))/(ub − lb).

Bold cost values indicate that no better solution was found by our heuristics. An ∗ is suffixed if the solution is proven optimal according to the results in [14]. When  = 0 then the instance is already solved to optimality during the initial cut generation phase. Algorithm (A) clearly outperforms (B), (C) and (D) in terms of number of best solutions found. As shown in Fig. 11, 98% of the best solutions are found by (A) compared to 37%, 66% and 73% for (B), (C) and (D). The run times for the whole instance set are about 68, 109, 14 and 26 h, respectively. Even though starting with a random solution in (B) helps finding better local optima than with the other strategies for 10 instances, the algorithm convergence is significantly slower. Moreover, it especially seems to suffer from the costly start solution for the larger instances. On average we observe 28 refinements and 84 GLBPs per instance for (B), compared to 1 and 38 for (A). Let us sum up the performance of (A) compared to existing approaches. We improve 42% of the solutions found by the initial heuristic and 65% of the heuristic results in [10]. On average we achieve an improvement of 1.6% for the problems without known optimal solutions. We improve 36% of the best known results that were obtained by the branch and cut algorithm in [14], reducing the optimality gap by 10% on average for the corresponding instances. However, we are not able to compete with the pure exact method for 15% of the problems. In [10] and [14], an Intel i7-3667U 2.00 GHz machine was used which has an about 10% lower performance than our machine. The time limit in the latter was set to one hour. The runtimes for the heuristic in [10] never exceeded 25 s. 2 lb and ub are the bounds computed by the branch and cut algorithm in [14]. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

13

Table 1 Results for the 225 TSPlib-based CRTP instances. P

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61

|U| 12

12

12

18

18

18

25

25

25

12

12

12

25

µ 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1

|W| m q 13

7

0

38

25

3

5

4

4

5

3

3

7

4

5

5

4

3

10

4

7

5

6

3

5

4

4

5

3

3

10

(A)

(B)

(C)

(D)

Best

c(N˜ )

c(N )

Ω

#

t

c(N˜ )

c(N )

Ω

#

t

c(N )

Ω

#

t

c(N )

Ω

#

t

γ

θ

157* 215 227* 236* 242* 163* 207* 240* 249* 251* 173 242* 251* 279* 279* 207* 256* 274* 292* 303 217* 285* 313* 334* 339* 227* 278* 336* 361* 375* 245* 294* 313* 327* 328* 252* 311* 345* 357* 362* 254* 319* 371 378* 397 156* 194 215 222* 242* 159* 209* 230* 238* 251* 172 203* 251* 278* 279* 248

157* 210* 227* 236* 242* 163* 207* 240* 249* 251* 170* 242* 251* 279* 279* 207* 256* 274* 292* 303 217* 285* 313* 334* 339* 227* 278* 336* 361* 375* 245* 294* 313* 327* 328* 252* 311* 345* 357* 362* 254* 319* 371 378* 396* 156* 194 215 222* 242* 159* 209* 230* 238* 251* 170* 203* 251* 278* 279* 245*

0 9 3 3 3 0 0 3 3 0 9 3 3 0 0 0 7 7 7 7 0 8 7 7 7 0 7 7 7 7 0 9 9 9 9 0 9 9 9 9 9 9 9 9 24 3 4 3 3 3 6 3 3 0 0 9 3 3 3 0 24

0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1

1 17 8 6 5 0 2 7 4 1 2 9 7 1 1 1 15 11 8 7 1 23 17 21 5 1 15 23 16 5 0 22 38 14 4 0 23 53 19 4 2 16 65 17 6 4 47 19 25 51 24 73 47 4 6 19 37 67 73 5 20

265 348 340 413 364 271 366 412 346 348 241 363 397 398 348 400 525 625 564 498 417 547 560 643 535 391 548 510 632 541 769 798 765 806 873 704 749 892 839 814 721 827 693 772 898 265 354 334 370 364 271 300 368 381 348 241 335 315 429 348 769

157* 210* 232 236* 242* 163* 207* 240* 249* 251* 170* 242* 251* 279* 279* 207* 256* 274* 292* 312 217* 285* 313* 334* 347 227* 283 336* 361* 375* 245* 294* 313* 328 333 252* 311* 348 357* 365 254* 319* 371 378* 396* 157 197 216 222* 242* 163 210 230* 238* 251* 170* 204 251* 278* 279* 245*

0 9 9 9 9 0 0 3 9 0 9 9 9 6 0 0 7 18 21 20 0 25 25 24 25 0 7 25 25 7 0 9 27 27 33 0 33 24 39 36 9 39 30 24 24 9 9 9 9 6 9 9 15 0 0 9 9 9 7 0 33

0 1 1 2 1 0 0 0 1 0 2 3 1 0 0 0 0 1 4 4 0 6 8 7 6 0 0 8 8 0 0 0 2 2 9 0 9 2 13 16 0 16 6 3 1 2 2 2 2 0 2 2 2 0 0 2 2 2 0 0 11

1 9 11 7 4 1 2 5 6 1 2 14 11 4 1 1 12 12 15 14 1 33 51 90 11 1 20 54 36 3 0 19 122 65 17 0 60 376 160 19 1 48 120 33 6 3 44 20 26 34 15 50 90 5 7 12 30 81 115 17 23

157* 210* 227* 236* 242* 163* 207* 240* 249* 251* 170* 242* 251* 279* 279* 207* 256* 274* 292* 303 217* 285* 313* 334* 339* 227* 278* 336* 361* 375* 245* 294* 313* 327* 328* 252* 311* 345* 357* 362* 254* 319* 371 378* 396* 156* 194 215 222* 242* 159* 209* 230* 238* 251* 170* 203* 251* 278* 279* 245*

0 9 3 3 3 0 0 3 3 0 9 3 3 3 0 0 4 4 4 4 0 5 4 4 4 0 4 4 4 4 0 6 6 6 6 0 6 6 6 6 6 6 6 6 18 3 3 3 3 3 4 3 3 0 0 9 3 3 3 0 18

0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1

1 14 7 5 5 0 1 7 5 1 2 8 8 3 1 1 8 8 4 6 1 11 10 7 4 1 10 11 9 4 0 8 8 4 2 0 10 10 7 3 1 7 12 6 4 3 33 19 27 46 20 63 45 3 5 16 31 55 59 12 15

157* 210* 227* 236* 242* 163* 207* 240* 249* 251* 170* 242* 251* 279* 279* 207* 256* 274* 292* 303 217* 285* 313* 334* 339* 227* 278* 336* 361* 375* 245* 294* 313* 327* 328* 252* 311* 345* 357* 362* 254* 319* 371 378* 396* 156* 194 215 222* 242* 159* 209* 230* 238* 251* 170* 203* 251* 278* 279* 245*

0 9 3 3 3 0 0 3 3 0 9 3 3 3 0 0 3 3 3 3 0 3 3 3 3 0 3 3 3 3 0 3 3 3 3 0 3 3 3 3 3 3 3 3 9 3 1 3 3 3 2 3 3 0 0 9 3 3 3 0 9

0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1

2 16 8 5 4 0 2 7 5 2 2 8 13 2 0 1 13 8 5 5 0 17 12 13 4 1 12 18 11 3 0 14 36 10 2 0 23 64 12 3 1 11 42 10 4 3 24 14 18 37 18 52 65 8 12 43 69 135 150 32 35

0 2.4 0 0 0 0.6 0 0 0 0 1.8 0.8 0 0 0 0 0 0 0 0.7 1.4 0 1.6 0 0 1.8 0 0 0 0 1.2 0 0 0 0 6 1.3 0 0 0 3.1 0.9 0.3 0.3 0.3 0 1 0 0 0 2.5 0 0 0 0 1.2 0 0 0 0 1.2

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

(continued on next page)

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

14

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

Table 1 (continued) 62 63 64 65 66 67 68 69 70 71 72 73 74 75

25

25

0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0

4

7

5

6

305 311* 322* 328* 252* 309 349 357* 362* 257 341 372 387 397

304 311* 322* 328* 252* 304* 349 357* 362* 254* 335 372 384 396

21 13 9 9 9 32 13 13 9 24 21 9 24 24

1 0 0 0 0 1 0 0 0 1 1 0 1 1

466 188 55 21 14 144 218 100 34 11 318 424 252 50

774 737 826 873 704 789 757 819 814 721 795 694 879 898

302 312 322* 328* 252* 307 352 358 365 254* 340 377 384 396

33 36 36 36 33 36 33 36 36 33 54 39 42 45

7 11 13 12 10 10 10 15 16 8 14 12 14 17

447 289 176 1381 23 203 401 213 68 15 962 814 564 85

305 311* 322* 328* 252* 304* 349 357* 362* 254* 341 372 384 396

6 6 6 6 6 18 6 6 6 18 6 6 18 18

0 0 0 0 0 1 0 0 0 1 0 0 1 1

51 35 29 15 9 58 96 32 24 7 45 60 49 33

304 311* 322* 328* 252* 304* 349 357* 362* 254* 335 372 384 396

9 3 3 3 3 9 3 3 3 9 9 3 9 9

1 0 0 0 0 1 0 0 0 1 2 0 1 1

705 64 32 14 9 66 114 43 26 7 208 272 238 32

1 0.3 0 0 6 5.3 0.9 0 0 3.1 1.2 0 0.8 0.3

100 0 0 0 0 0 72.2 0 0 0 100 100 80 0

Fig. 11. Total number of instances by number of customers and number of best solutions found by heuristics (A), (B), (C) and (D).

Fig. 12. GLB scheme (left) and average number of edge variable flips per improvement for different instance sizes (right).

5.4. Algorithm analysis To better understand the algorithm performance we provide further details about the computations with configuration (A) in this section. In the following we break down the computational details into the different numbers of instance customers for each GLBP parameterization over all the 225 instances. [|U | ∈ {12, 18, 25, 37, 50, 56, 75, 100}; #instances: 30, 30, 45, 30, 30, 15, 30, 15 (see also Fig. 11).] We recall that these pairs of k and r = |B| in the GLB scheme are computed in advance based on an initial calibration. Depending on |U | we utilize the first pairs (k1 , r1 ), . . . , (kh , rh ) such that rh−1 < |U | and rh ≥ |U |. The used scheme is shown in Fig. 12 (left). The average number of edge variable flips by a single solution refinement is illustrated in Fig. 12 (right). We show this number for the different cluster sizes (x-axis) and the different instance sizes (|U | + |W |). It can be seen that the clusters on 14 and 26 nodes led to 4–11 variable changes on average. At the same time, refinements were mostly identified when considering these cluster sizes. Even though these average values range within [0, k] as expected, the used local search procedures might lead to best (GLBP-infeasible) solutions beyond the allowed Hamming distance to the incumbent. Fig. 13 shows the total number of GLBPs (left) and the number of improvements found (right) for each parameterization and number of customers. The majority of improvements, except for instances with |U | = 75, are carried out when considering balls of size 14 and 26. In total, solving 227 (2.7%) of 8514 GLBPs result in an improved solution. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

15

Table 2 Results for the 225 TSPlib-based CRTP instances. P

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139

|U| µ 37

37

37

50

50

50

18

18

18

37

37

37

56

1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25

|W| m q 13

0

57

38

19

3

14

4

11

5

9

3

19

4

14

5

12

3

7

4

5

5

4

3

14

4

11

5

9

3

21

(A)

(B)

(C)

(D)

Best

c(N˜ ) c(N ) 

# t

c(N˜ )

c(N ) 

#

t

c(N ) 

# t

c(N ) Ω # t

γ

θ

304* 369 376 380 380* 309 369 399 404 412 314* 406 429 447 448 376* 427 447 454 463 386 442 475 502 494 392 489 515 531 533 214 272* 307 318 331* 235 306 336* 368 390 259 325* 377 397* 448* 320* 387 393 403 410 336 402 435 457 458 343 446 472 493 500 388 455 460 465

0 0 0 1 0 0 1 1 0 0 0 3 2 1 1 0 0 1 0 0 1 0 1 1 1 1 3 2 2 3 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 2 0 1 0 3 1 1 2 0 1 2 3 4 4 4 0 0 0

1205 1135 1231 1224 1208 1208 966 1341 1328 1259 1107 1152 1190 1264 1351 1442 1512 1681 1693 1669 1388 1744 1647 1674 1681 1561 1687 1726 1871 1762 569 549 639 553 676 548 527 589 618 812 602 565 673 660 781 1071 1171 1321 1151 1226 1074 1085 1325 1422 1291 1085 1078 1167 1394 1312 1862 1903 1899 2056

304* 363 376 379* 380* 308* 363* 410 422 416 314* 434 424 433 452 376* 426 448 454 464 384* 442 484 500 493* 390* 480 512 525 529 217 273 315 318 333 236 310 337 369 392 260 327 379 399 458 325 396 397 406 411 330 424 455 454 464 342 462 471 480 494 383* 476 471 473

20 17 28 23 2 18 21 21 25 26 23 24 23 26 34 0 35 57 59 48 27 42 49 66 51 32 34 57 70 62 6 7 6 7 5 7 5 4 10 5 6 5 7 7 4 22 25 26 23 25 17 27 31 36 22 17 30 34 43 34 33 49 52 2

12 331 1588 294 28 14 319 1022 355 93 31 1193 1673 907 126 0 700 2161 640 116 36 3319 3680 4014 383 70 3886 2899 2328 513 13 309 584 1315 86 23 313 179 362 82 53 304 354 139 80 53 2021 1637 368 124 85 2254 1660 1432 305 125 3836 2659 2517 476 119 5728 5006 914

304* 369 376 379* 380* 309 369 398 404 412 314* 404 423 447 446* 376* 427 444 454 463 384* 442 475 498 494 391 485 515 525 526 214 272* 307 318 330 235 306 336* 367 390 259 325* 376 397* 448* 320* 387 393 403 410 326* 402 434 454 458 342 445 472 484 491 387 455 460 465

0 0 0 1 0 0 0 1 0 0 0 1 2 0 1 0 0 1 0 0 1 0 0 1 0 1 2 0 2 3 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 3 0 1 2 0 1 1 0 2 2 1 0 0 0

304* 369 376 380 380* 309 363* 398 404 412 314* 406 423 447 446* 376* 427 447 454 463 384* 442 475 502 494 391 489 515 531 533 214 272* 307 318 330 235 306 336* 367 390 259 325* 376 397* 448* 320* 387 393 403 410 326* 402 435 457 458 342 446 468 493 500 387 455 460 465

0 3.3 0.5 0.3 0.3 0.3 1.7 0.3 0 1.4 0 2 1.9 0.7 1.3 0.3 2.3 0.7 0 2.1 0.5 3.6 3.9 0.8 4.1 0.5 4.4 2.7 0 2.8 0 0 3.5 0 0.6 0 1.9 0 0.5 0 0 0 0.8 0 0.7 0 2.8 2.2 0.2 0.7 3 0.2 4.6 2.4 0 0.3 1.6 2.1 3.8 4.2 3.1 1.5 3.6 1.5

0 51.8 100 0 0 0 0 93.4 100 0 0 76.2 73.5 84.6 0 0 88.7 90 0 0 0 54.6 57.6 87.1 0 0 75 70.7 100 100 0 0 63.9 100 0 0 54.5 0 80.5 0 0 0 72.8 0 0 0 58.5 69.8 92.5 0 0 95 52.9 74.1 100 0 82 78.6 64.9 26.5 0 79.9 56.2 100

304* 369 376 379* 380* 309 363* 398 404 412 314* 400 423 441 446* 376* 427 444 454 463 384* 442 474 498 493* 391 482 512 525 526 214 272* 307 318 330 235 306 336* 367 390 259 325* 376 397* 448* 320* 379 393 402 410 326* 401 434 449 458 342 439 463 478 485 383* 455 460 465

16 16 16 40 16 16 37 49 20 16 16 45 49 37 40 0 27 65 27 27 65 27 60 65 60 65 71 66 65 76 8 8 8 8 21 8 8 8 21 8 8 8 21 8 8 21 51 21 47 20 51 47 51 77 21 51 55 45 65 56 81 32 32 32

9 622 434 211 26 13 198 648 145 38 16 1123 2168 1147 73 0 398 450 72 33 24 626 2412 646 68 41 2492 1889 679 92 9 460 595 529 197 17 269 355 698 159 74 351 528 228 135 57 1204 1227 665 102 121 2799 1904 2810 195 158 3463 2777 3168 448 135 2450 1883 477

69 64 98 93 45 61 64 64 77 67 66 66 72 72 82 0 105 162 194 163 105 143 178 182 192 135 149 170 208 195 25 21 21 39 22 25 21 18 29 22 21 21 25 26 18 69 98 88 61 61 61 109 74 117 61 61 100 111 119 109 126 180 199 71

8 8 8 24 8 8 8 27 9 8 8 24 27 8 24 0 11 33 11 11 33 11 11 33 11 33 33 11 33 44 5 5 5 5 15 5 5 5 15 5 5 5 15 5 5 9 9 9 9 9 27 9 27 27 9 27 27 9 36 27 36 13 13 13

6 58 56 43 17 9 52 86 34 23 10 145 161 58 40 0 47 85 21 14 10 81 125 61 18 14 139 128 65 35 6 278 193 180 137 10 137 179 348 124 56 173 230 119 100 25 172 183 81 48 61 238 257 254 88 60 581 205 534 171 41 424 352 92

3 3 3 3 3 3 9 9 3 3 3 3 9 3 9 0 3 3 3 3 9 3 3 3 3 9 3 3 3 3 3 3 3 3 9 3 3 3 9 3 3 3 9 3 3 3 3 3 3 3 9 3 3 3 3 9 3 9 3 3 9 3 3 3

0 0 0 0 0 0 1 1 0 0 0 0 1 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 2 0 0 0 0 1 0 1 0 0 1 0 0 0

5 286 365 181 46 25 303 506 130 66 32 445 947 380 128 1 209 174 45 40 28 348 523 193 50 45 400 464 239 69 17 451 427 459 437 33 337 425 891 336 159 483 885 365 218 72 508 471 283 132 169 504 469 501 262 169 535 1065 790 455 123 779 704 230

(continued on next page)

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

16

A. Hill, S. Voß / Discrete Applied Mathematics (

)

32 32 77 32 32 32 84 72 77 77 32

476* 389* 472 507 522 528 411 524 541 556 557

–

Table 2 (continued) 140 141 142 143 144 145 146 147 148 149 150

56

56

0 1 0.75 0.5 0.25 0 1 0.75 0.5 0.25 0

4

16

5

13

476* 389* 476 507 522 528 414 527 542 558 557

476* 389* 472 507 522 528 399* 522 538 553 557

0 0 3 0 0 0 4 3 2 1 0

148 121 4513 2024 1670 249 227 3021 4688 1752 168

1761 1856 1608 1860 1908 1793 1809 1835 1669 1820 1803

477 395 475 516 530 531 400 561 546 551 559

196 131 181 208 171 198 130 190 171 193 200

54 49 41 56 68 54 43 50 50 56 58

705 186 5097 5848 3789 672 197 6871 5497 3713 738

13 13 39 13 13 13 39 39 39 39 13

0 0 3 0 0 0 1 1 1 1 0

71 64 503 248 179 90 113 668 791 363 52

476* 389* 474 507 522 528 413 527 542 558 557

3 3 9 3 3 3 9 3 3 3 3

0 0 1 0 0 0 1 0 0 0 0

158 157 1127 637 588 233 220 660 1038 660 119

3.8 3.2 3.3 2.5 1.9 2.8 3.6 2.1 2.9 1.3 0.7

0 0 66.2 76 74.7 67.1 0 82.7 73.9 84.7 100

Fig. 13. Number of GLBPs (left) and number of improvements (right).

Fig. 14. Average relative objective improvement (left) and average runtime (right).

The average GLBP improvement of the network costs is given in Fig. 14 (left). These numbers support that k ∈ {14, 26} does not only yield the most improvements, but also the highest cost reduction per improvement on average. Fig. 14 (right) shows the average run times of the exact algorithm for the GLBPs using the time limit of 120 s. Even though some parameterizations and instance classes tend to yield more time consuming GLBPs for the solver, our GLB scheme seems to be well balanced within the used framework. Finally, 1.5% of the overall runtime is spent for GLBPs that lead to an improvement. Fig. 15 (left) shows the average relative optimality gap at the root node. These results seem to be related with the average runtimes in Fig. 14 (right). Therefore, the root node gap might be a good indicator for the hardness of a GLBP. The average number of explored nodes within the branch and cut method is given in Fig. 15 (right). 93.6% of the GLBPs could be solved within the time limit. The average optimality gap when the GLBP could not be solved and the time limit was reached is illustrated in Fig. 16 (left). Fig. 16 (right) shows the number of GLBPs that could not be solved. GLBPs with r = k = 14 were mostly solved to optimality since this was a finding of our initial GLB calibration, as Fig. 14 (right) already suggests. For instances with |U | ∈ {37, 56, 75} up to 45% of the GLBPs could not be solved. We recall that this does not necessarily mean that no improving solution was found by the exact method. Finally, we would like to mention that we also experimented with a strategy (A′ ) which utilizes the reversed (A) GLB scheme. In other words, we considered balls of large size first and incrementally made them smaller while increasing k. We observed that for 8 instances better solutions than those obtained with (A) were found and for 2 instances (A′ ) could not compete with (A). The total runtimes of both strategies are comparable and we could not obtain a clear indication for a dominance relation. However, we think that the deeper analysis of different strategies would be worth investigating in future research. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

17

Table 3 Results for the 225 TSPlib-based CRTP instances. P

|U|

µ

|W| m q

(A)

(B)

c(N˜ ) c(N ) Ω 151 75 1 0 152 0.75 153 0.5 154 0.25 155 0 156 75 1 157 0.75 158 0.5 159 0.25 160 0 161 75 1 162 0.75 163 0.5 164 0.25 165 0 166 25 1 75 167 0.75 168 0.5 169 0.25 170 0 171 25 1 172 0.75 173 0.5 174 0.25 175 0 176 25 1 177 0.75 178 0.5 179 0.25 180 0 181 50 1 50 182 0.75 183 0.5 184 0.25 185 0 186 50 1 187 0.75 188 0.5 189 0.25 190 0 191 50 1 192 0.75 193 0.5 194 0.25 195 0 196 75 1 25 197 0.75 198 0.5 199 0.25 200 0 201 75 1 202 0.75 203 0.5 204 0.25 205 0 206 75 1 207 0.75 208 0.5 209 0.25 210 0 211 100 1 0 212 0.75

3

4

5

3

4

5

3

4

5

3

4

5

3

28 478 546 558 573 576 21 494 572 588 618 620 17 495 598 623 652 662 10 280 317 352 363 366* 7 293 367 400 416 424 6 298 385 403 429 452 19 411* 481 499 501 506 14 420 477 505 531 534 12 436 505 527 559 574 28 516 581 591 612 608 21 517 589 607 619 638 17 526 642 639 666 674 38 555* 642

473* 542 551 573 572* 486 556 584 613 612 488* 575 617 641 662 280 315 352 363 366* 293 367 400 416 424 298 383 403 429 452 411* 481 499 501 506 420 475 505 531 534 428 501 516 551 568 513 580 587 602 608 517 584 603 619 637 525 630 634 663 673 555* 635

0 101 102 43 108 123 94 99 111 102 98 88 108 105 42 13 32 13 14 13 14 13 13 13 34 35 35 13 14 14 28 28 28 65 27 27 78 29 28 28 116 77 96 73 67 93 51 86 111 44 44 54 59 44 97 111 48 59 87 102 56 71

(C)

(D)

# t

c(N˜ ) c(N ) Ω

#

t

c(N ) Ω

# t

0 4 3 3 051 3 2 631 0 556 2 224 5 213 5 6 275 2 5 506 4 2 407 4 314 2 211 6 3 071 4 6 060 5 4 282 0 393 0 91 1 1 371 0 740 0 518 0 225 0 47 0 1 408 0 1 279 0 891 1 370 1 77 1 2 527 0 1 300 0 797 0 311 0 56 0 2 398 0 1 944 1 1 234 0 287 0 101 2 2 717 0 936 0 1 199 0 269 5 307 3 6 116 6 1 498 3 1 951 2 686 2 269 4 5 632 2 4 213 4 2 278 0 255 0 182 3 5 952 4 5 665 0 1 074 1 634 3 337 3 6 514 2 4 999 2 3 145 1 627 0 218 5 10 093

2616 473* 2430 554 2465 552 2519 561 2713 612 2552 482* 2586 589 2523 587 2717 618 2731 637 2425 491 2544 593 2770 701 2524 666 2672 662 836 282 804 316 770 349 831 367 984 368 809 295 904 373 786 404 974 417 1049 426 918 302 840 385 940 405 908 427 1007 468 1780 412 1798 486 1736 501 1957 505 2020 506 1925 420 1703 489 1839 511 1865 532 2016 535 1724 428 1704 502 1588 517 1985 555 2051 575 2542 514 2856 593 2716 597 2883 620 2794 610 2866 518 2720 600 2811 604 2651 621 2774 638 2673 526 2569 629 2812 648 2567 665 2852 669 3608 1161 3318 880

0 73 89 109 108 59 99 98 116 117 68 93 97 109 103 10 10 11 10 10 13 10 9 15 9 15 11 12 17 14 31 40 50 52 55 37 34 54 43 59 37 40 48 56 60 53 74 80 110 121 70 73 94 109 108 68 77 104 96 114 67 119

3 6 273 3 334 2 489 1 584 171 11 264 6 717 5 689 1 293 321 13 122 12 065 7 123 2 435 61 669 457 376 152 47 1 443 1 023 716 164 45 1 212 723 915 214 86 6 113 4 728 1 271 891 283 2 624 4 523 1 551 679 249 2 617 1 680 2 395 899 203 7 507 5 653 4 384 1 159 619 9 043 9 184 4 127 1 338 410 11 699 9 711 6 494 1 871 331 11 755

473* 543 558 573 572* 487 563 588 615 620 495 598 622 646 662 280 315 352 363 366* 293 367 400 416 424 298 383 403 429 452 411* 481 499 501 506 420 477 505 531 534 428 504 520 559 568 516 580 590 604 608 517 587 605 619 638 527 630 637 663 673 555* 640

0 4 473* 2 622 546 0 405 558 0 92 573 1 75 576 4 55 494 2 929 572 0 515 588 3 192 617 0 76 620 0 45 495 0 520 598 1 758 623 2 277 652 0 75 662 0 62 280 1 273 317 0 251 352 0 223 363 0 148 366* 0 16 293 0 416 367 0 343 400 0 228 416 1 204 424 1 20 298 1 850 385 0 340 403 0 286 429 0 180 452 0 23 411* 0 442 481 0 365 499 1 303 501 0 174 506 0 51 420 1 801 477 0 310 505 0 243 531 0 120 534 4 87 436 1 667 505 6 552 527 1 434 559 2 336 574 0 55 516 4 989 581 1 967 591 3 724 612 0 122 608 0 76 517 1 784 589 2 1005 607 0 368 619 0 152 638 2 85 526 5 1044 642 1 784 639 3 708 666 1 236 674 0 115 555* 1 1922 642

0 209 297 295 314 189 350 294 328 293 240 379 366 342 337 33 33 33 36 30 42 48 33 36 30 42 36 33 60 36 99 162 164 166 171 151 107 194 115 192 97 120 197 138 179 192 264 268 335 374 298 259 303 354 318 265 341 335 312 339 334 408

0 45 15 16 45 60 45 15 48 15 15 15 45 48 15 6 18 6 7 6 7 6 6 6 20 21 21 6 7 7 11 11 11 33 11 11 33 11 11 11 44 33 55 33 33 16 51 48 64 16 16 48 48 16 16 48 48 48 64 48 21 63

Best

c(N ) Ω 0 3 3 3 3 3 3 3 9 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 9 9 3 3 3 3 3 3 3 9 3 3 9 3 3 3 3 3 3 9 3 4 16 4 3 4 4 3 4 4 4 9 3 3 3 3 4 4

# t

γ

θ

0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 2 0 0 2 0 0 0 0 0 0 1 0 0 3 0 0 0 0 0 0 0 0 2 0 0 0 0 0 0

1.1 1.6 2.3 2.1 2.1 2.5 3 4.6 0.8 2.2 1.4 7.7 1 2.3 1.8 0.7 3.7 1.1 0 0 0 0 1.2 0 0.2 0.3 2.5 0 0.5 0 0 2.2 0 0.4 3.4 0 1 2.3 0 0.6 3.5 0.8 2.1 2.3 1 0.6 2.4 0.8 1.6 2.3 0.4 1.8 0.7 0 0.8 0.8 3.8 1.7 1 3 0 2.6

0 74.4 52.7 71.2 0 0 59.7 53.4 84.4 39.7 0 32.1 84.2 68.9 63.9 0 0 75.5 100 0 0 100 86.7 100 93.8 0 68.6 100 90.9 100 0 68.5 100 89.8 86.5 0 74.7 64.1 100 75.4 0 83.5 65.9 68.6 71.3 0 64.2 77.5 59 0 0 69.2 83.9 100 86.7 0 65.2 76.6 85.4 49.8 0 58.2

9 770 984 282 178 108 1051 1395 691 195 125 1325 1351 529 251 154 601 584 489 357 50 838 745 553 522 51 634 607 698 453 55 688 912 703 396 113 1169 681 572 269 127 875 912 1179 727 154 2412 1249 970 324 198 1192 1844 863 394 206 1404 1270 729 435 297 2141

(continued on next page)

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

18

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

Table 3 (continued) 213 0.5 214 0.25 215 0 216 100 1 217 0.75 218 0.5 219 0.25 220 0 221 100 1 222 0.75 223 0.5 224 0.25 225 0

4

5

647 656 674 28 568 661 679 690 700 23 575 684 717 729 729

641 652 666 564* 658 672 687 692 574 670 708 717 720

115 133 133 133 70 89 145 166 145 92 73 123 133

5 4 712 3279 967 2 2 195 3445 1104 2 567 3458 1163 1 358 3195 971 2 9 428 3288 1210 3 7 644 3578 1124 3 2 639 3466 883 4 698 3525 1181 2 330 3297 1102 6 11 271 3282 1008 4 10 367 3565 1032 3 3 674 3640 1152 2 692 3530 1155

400 390 429 228 389 442 420 508 322 585 488 452 486

126 131 147 67 94 140 137 153 71 124 141 134 159

7 458 5 099 1 502 271 10 952 10 838 6 451 2 140 408 19 657 13 613 6 215 1 785

642 652 666 564* 658 677 690 695 575 676 714 720 725

63 63 63 63 63 63 63 84 63 105 63 63 63

3 2 2 1 2 1 1 2 1 4 2 2 1

1094 567 227 118 1980 2191 532 244 111 3129 2807 609 266

647 656 674 568 661 679 690 700 575 684 717 729 729

12 4 12 4 4 4 12 4 12 4 4 4 4

1 0 1 0 0 0 1 0 1 0 0 0 0

2671 673 574 236 2419 3119 1256 515 374 2873 4102 876 495

2.9 0.6 2.5 0.7 0.8 2.6 0.6 1.1 0.3 3.6 1.3 1.8 3.1

51.6 100 0 0 87.1 60.8 100 50.9 0 62.1 79.1 68.3 33.1

Fig. 15. Average GLBP root node gap (left) and average number of explored GLBP branching nodes (right).

Fig. 16. Average relative optimality gap when the time limit is reached (left) and number of unsolved GLBPs (right).

6. Conclusions We presented a novel heuristic framework to solve a broad class of network design problems. A key ingredient is GLB, a concept that generalizes the ideas of local branching and local refinement techniques based on mathematical programming. GLB refinement problems are created by the addition of GLB cuts to an ILP formulation of the overall problem. These are iteratively solved while increasing the number of involved decision variables and at the same time decreasing the number of variable flips. Hereby, we control the complexity of these subproblems in order to solve them to optimality. Using this idea we designed a heuristic for the CRTP based on an exact branch and cut algorithm. This approach turned out to be powerful as we were able to obtain new best solutions for literature instances. Compared to the pure MIP refinements or local branching it produced significantly more best solutions. The proposed approach represents a promising strategy when no improving solution can be found by other algorithms at hand (in our case a multi-start local search heuristic and an exact algorithm). As is typical for exact refinement methods, the ability to incrementally enlarge the refinement neighborhoods results in an adjustable algorithm performance. Using the presented solutions as a starting point for an exact algorithm could significantly accelerate the solution process and improve the obtained bounds. Moreover, the techniques could be integrated into an exact method to effectively polish feasible solutions that are found along the search. The study of extended problem-specific solution refinement substructures, beside the used single-balls, could further improve the results. Furthermore, we suggest to transfer our techniques to related optimization models in network design to study their effectiveness. Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.

A. Hill, S. Voß / Discrete Applied Mathematics (

)

–

19

Acknowledgments We are indebted to Bernard Fortz and Malte Fliedner for their useful comments. Furthermore, we thank the anonymous referees for their careful review of our work. References [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] [16] [17] [18] [19] [20] [21] [22] [23]

F.H.N. Abe, E.A. Hoshino, A. Hill, The ring tree facility location problem, Electron. Notes Discrete Math. 50 (2015) 331–336. C. Archetti, L. Bertazzi, A. Hertz, M.G. Speranza, A hybrid heuristic for an inventory routing problem, INFORMS J. Comput. 24 (2012) 101–116. T. Berthold, RENS, Math. Program. Comput. 6 (1) (2014) 33–54. S. Cafieri, P. Hansen, L. Liberti, Improving heuristics for network modularity maximization using an exact algorithm, Discrete Appl. Math. 163 (1) (2014) 65–72. E. Danna, E. Rothberg, C. Le Pape, Exploring relaxation induced neighborhoods to improve MIP solutions, Math. Program. A 102 (1) (2005) 71–90. R. De Franceschi, M. Fischetti, P. Toth, A new ILP-based refinement heuristic for vehicle routing problems, Math. Program. B 105 (2–3) (2006) 471–499. M. Fischetti, F. Glover, A. Lodi, The feasibility pump, Math. Program. B 104 (1) (2005) 91–104. M. Fischetti, A. Lodi, Local branching, Math. Program. B 98 (1–3) (2003) 23–47. W.D. Harvey, M.L. Ginsberg, Limited discrepancy search, in: C.S. Mellish (Ed.), Proceedings of the 14th International Joint Conference on Artificial Intelligence, Vol. 1, IJCAI 1995, Morgan Kaufmann, 1995, pp. 607–615. A. Hill, Multi-Exchange Neighborhoods for the Capacitated Ring Tree Problem, in: Springer Lectures Notes Computer Science, vol. 8962, 2015, pp. 85–94. A. Hill, Models and Algorithms for Extended Network Design, University of Hamburg, 2016 URL http://ediss.sub.uni-hamburg.de/volltexte/2017/8149. A. Hill, S. Schwarze, Exact algorithms for bi-objective ring tree problems with reliability measures, preprint, Optimization Online, 2016. A. Hill, S. Voß, An equi-model matheuristic for the multi-depot ring star problem, Networks 67 (3) (2016) 222–237. A. Hill, S. Voß, Optimal capacitated ring trees, EURO J. Comput. Optim. 4 (2) (2016) 137–166. E.A. Hoshino, A. Hill, A column generation approach for the capacitated ring tree problem, in: Proceedings of XVIII ALIO/EURO Workshop on Applied Combinatorial Optimization, 2014. E. Lalla-Ruiz, S. Voß, POPMUSIC as a matheuristic for the berth allocation problem, Ann. Math. Artif. Intell. 76 (2016) 173–189. J. Lazić, S. Hanafi, N. Mladenović, D. Urošević, Variable neighbourhood decomposition search for 0-1 mixed integer programs, Comput. Oper. Res. 37 (6) (2010) 1055–1067. P. Legato, R. Trunfio, A local branching-based algorithm for the quay crane scheduling problem under unidirectional schedules, 4OR 12 (2) (2014) 123–156. V. Maniezzo, T. Stützle, S. Voß (Eds.), Matheuristics - Hybridizing Metaheuristics and Mathematical Programming, in: Annals of Information Systems, vol. 10, Springer, 2010 Matheuristics. Z. Naji-Azimi, M. Salari, P. Toth, An integer linear programming based heuristic for the capacitated m-ring-star problem, European J. Oper. Res. 217 (1) (2012) 17–25. I. Rodríguez-Martín, J.J. Salazar-González, A local branching heuristic for the capacitated fixed-charge network design problem, Comput. Oper. Res. 37 (3) (2010) 575–581. P. Smet, T. Wauters, M. Mihaylov, G.V. Berghe, The shift minimisation personnel task scheduling problem: A new hybrid approach and computational insights, Omega 46 (2014) 64–73. M. Sniedovich, S. Voß, The corridor method: A dynamic programming inspired metaheuristic, Control Cybernet. 35 (3) (2006) 551–578.

Please cite this article in press as: A. Hill, S. Voß, Generalized local branching heuristics and the capacitated ring tree problem, Discrete Applied Mathematics (2017), https://doi.org/10.1016/j.dam.2017.09.010.