Thinning out Steiner trees: a nodebased model for uniform edge costs
 1.8k Downloads
 18 Citations
Abstract
The Steiner tree problem is a challenging NPhard problem. Many hard instances of this problem are publicly available, that are still unsolved by stateoftheart branchandcut codes. A typical strategy to attack these instances is to enrich the polyhedral description of the problem, and/or to implement more and more sophisticated separation procedures and branching strategies. In this paper we investigate the opposite viewpoint, and try to make the solution method as simple as possible while working on the modeling side. Our working hypothesis is that the extreme hardness of some classes of instances mainly comes from overmodeling, and that some instances can become quite easy to solve when a simpler model is considered. In other words, we aim at “thinning out” the usual models for the sake of getting a more agile framework. In particular, we focus on a model that only involves node variables, which is rather appealing for the “uniform” cases where all edges have the same cost. In our computational study, we first show that this new model allows one to quickly produce very good (sometimes proven optimal) solutions for notoriously hard instances from the literature. In some cases, our approach takes just few seconds to prove optimality for instances never solved (even after days of computation) by the standard methods. Moreover, we report improved solutions for several SteinLib instances, including the (in)famous hypercube ones. We also demonstrate how to build a unified solver on top of the new nodebased model and the previous stateoftheart model (defined in the space of arc and node variables). The solver relies on local branching, initialization heuristics, preprocessing and local search procedures. A filtering mechanism is applied to automatically select the best algorithmic ingredients for each instance individually. The presented solver is the winner of the DIMACS Challenge on Steiner trees in most of the considered categories.
Keywords
Mixed integer programming Exact computationMathematics Subject Classification
90C10 90C271 Introduction
The Steiner tree problem (STP), in any of its various versions, is a challenging NPhard problem that involves two related decisions: choosing the nodes to cover, and then covering them at minimum cost. Once the first decision has been taken, the second one is just trivial as it amounts to solving a minimumcost tree spanning the selected nodes.
In this paper we introduce a new mixedinteger linear programming (MIP) approach for solving hard instances of the Steiner tree problem (close) to optimality. Instead of modeling graph connectivity using edge or arc variables (where many of them can exist), we propose to model it by using node variables only. Our model is particularly suited for “uniform” cases where all edges have the same cost. Besides the fact that these nodebased models contain significantly less variables, they also avoid equivalences induced by uniform edge weights. For very dense graphs, or those containing a lot of symmetries, this strategy significantly outperforms the standard models where connectivity is modeled by using edge variables. We then demonstrate how to build a unified solver on top of the new nodebased model and the previous stateoftheart model from [22] (defined in the space of arc and node variables). The solver relies on local branching, initialization heuristics, preprocessing and local search procedures. A filtering mechanism is applied to automatically select the best algorithmic ingredients for each instance individually.
Our approach works for different variants of the Steiner tree problem, including the (rooted) prizecollecting STP (PCSTP), the nodeweighted STP (NWSTP), the maximumweight connected subgraph problem (MWCS), and also the degreeconstrained STP (DCSTP). To have a unified framework, in the following we will therefore focus on a slightly more general variant of the PCSTP, with a (potentially empty) set of terminal nodes. This general problem definition covers both the classical Steiner tree problem in graphs and its prizecollecting counterpart, as special cases. Necessary adaptations for the remaining problems will be explained below. It is worth mentioning that our code (with four variants submitted under the names mozartballs, staynerd, hedgekiller and mozartduet) was the winner of the DIMACS Challenge on Steiner trees [1] in most of the categories (see [12] for more details). This article contains a summary of the main ingredients of this implementation.
Definition 1
In the classical PCSTP version studied in the previous literature, \(T_r = \emptyset \), and the problem can be equivalently stated as searching for a subtree that maximizes the difference between the collected node revenues (\(\sum _{i \in V[\mathscr {T}]} p_i\)) and the costs for establishing the links of that tree (\(\sum _{e \in E[\mathscr {T}]} c_e\)). One objective value can be transformed into another by subtracting \(c(\mathscr {T})\) from the sum of all node revenues (\(P = \sum _{i \in V} p_i\)).
In general, each node in \(V{\setminus }T_r\) is considered as a Steiner node, i.e., it can be used as an intermediate node to connect real terminals, or those with positive revenues.
Observe that there always exists an optimal PCSTP solution in which nonterminal nodes with zero revenue are not leaves. The same holds for each node \(i \in V\) such that \(p_i > 0\) and \(\min _{\{i,j\} \in E} c_{ij} > p_i\). Note that we impose strict inequality in the latter condition. Hence, besides real terminals only a specific subset of nodes in the PCSTP can be leaves of an optimal solution. We will refer to those nodes as potential terminals.
Definition 2
In the following, we will call the set \(T = T_r \cup T_p\), the set of terminal nodes. Our general problem definition covers the Steiner tree problem in graphs, since in this case all node revenues are equal to zero (\(p_v = 0\), for all \(v \in V\)) and the set of real terminals is nonempty, i.e., \(\emptyset \ne T = T_r \subset V\).
Constraints (5) have been added to allow the incorporation of real terminals \(T_r\) into the model, which have not been considered in [22]. Note that if \(T_r\ge 1\), instead of adding an artificial root and its associated arcs, it is sufficient to choose an arbitrary real terminal \(v \in T_r\) as root. In this scenario constraint (4) must be excluded from the model.
The formulation may be augmented with further valid or strengthening inequalities, e.g., flowbalance inequalities, root asymmetry constraints, and generalized subtour elimination constraints (GSEC) of size two (cf. [22] for details). The advantage of this formulation is that it makes little assumptions on instance structure, however the number of arc variables may be computationally prohibitive on dense graphs. Throughout this article, we will refer to this formulation as (x, y)model.
2 A nodebased MIP model
Nodebased models for solving the maximumweight connected subgraph problem have been compared, both theoretically and computationally, in a recent publication [2]. Since there are no edgecosts involved in the objective of the MWCS, a natural MIP modeling approach is to derive a formulation in the space of node variables only. The first nodebased model for the MWCS has been proposed in [5], and has been shown to computationally outperform extended formulations (involving both edge and node variables) on a benchmark set of instances from bioinformatics applications. However, as demonstrated in [2], the cycleelimination model of [5] provides arbitrarily bad lower bounds and can be computationally improved by considering the notion of node separators whose definition is provided below. For brevity, in the rest of the article a node separator will be referred to simply as separator.
For STP/PCSTP instances, uniform edge costs can be embedded into node revenues (as shown below), so that using nodebased MIPs appears natural in this case.
Definition 3
(Node separators) For two distinct nodes k and \(\ell \) from V, a subset of nodes \(N \subseteq V {\setminus } \{k,\ell \}\) is called \((k,\ell )\)separator if and only if after eliminating N from V there is no \((k,\ell )\) path in G. A separator N is minimal if \(N{\setminus } \{i\}\) is not a \((k,\ell )\)separator, for any \(i \in N\). Let \(\mathscr {N}(k,\ell )\) denote the family of all \((k,\ell )\)separators.
Note that in order to make sure that a subset of chosen nodes is connected, it is sufficient to impose connectivity between the pairs of terminals (due to the minimization of the objective function). Therefore, we are mainly interested in separators between pairs of terminals.
Let \(\mathscr {N}_{\ell } = \cup _{k \in T, k \ne \ell } \mathscr {N}(k,\ell )\) be the family of all such separators with respect to a node \(\ell \in T\). We will refer to elements from \(\mathscr {N}_{\ell }\) as \(\ell \)separators. Finally, let \(\mathscr {N}= \cup _{\ell \in T} \mathscr {N}_\ell \) be the set of all node subsets that separate two arbitrary terminals.
Let us assume that we are dealing with an undirected graph G with node revenues \(p_v\) and uniform edge costs \(c_e = c\) for all \(e \in E\).
Connectivity constraints (8) are used to ensure connectivity of the underlying solution. Basically, whenever two distinct terminals \(i,j \in T\) are part of a solution, at least one node from any separator \(N \in \mathscr {N}(i,j)\) has to be chosen as well, in order to ensure that there exists a path between i and j.
There is a difference between our model and the one considered in [2], where a more general MWCS variant on digraphs has been studied. In this latter variant, a root node needs to be established, i.e., a node r with indegree zero and such that there is a directed path from r to any node j being part of the solution. Consequently, an additional set of node variables was needed to locate the root, separators were defined on digraphs, and connectivity constraints have been lifted with respect to root variables. Since our input graphs are undirected, we rely on the undirected model to keep the number of variables as small as possible. Only very recently, connectivity constraints (8) were given more attention in the literature concerning polyhedral studies. In particular, [26] studies the connected subgraph polytope, involving node variables only, and show that (8) define facets if and only if N is a minimal separator separating i and j.
It is sufficient to consider only minimal separators in inequalities (8) (since they dominate the remaining ones). In order to derive minimal separators associated to nodedegree constraints, we observe that nodes from \(V{\setminus } T\) that are only adjacent to i and other nodes from \(A_i\) do not play a role in connecting i to the remaining terminals. Let J be the set of all such neighbors of a given \(i\in T\), i.e., \(J = \{j \in A_i{\setminus } T \mid A_j \subseteq A_i \cup \{i\}\}\). If \(V{\setminus } A_i\) contains other terminals, then \(A_i {\setminus } J\) is a minimal iseparator, and we can correspondingly strengthen the nodedegree inequalities (11).
2.1 Separation of connectivity constraints
Whenever we want to cut off a fractional solution \(\tilde{y}\), we can separate the connectivity cuts (8) by applying a maximum flow algorithm. For each pair of distinct terminals (i, j) such that \(\tilde{y}_i + \tilde{y}_j  1 > 0\), one would need to find a minimum (i, j)cut in a support digraph D which is constructed as follows. First, each edge \(e \in E\) is replaced by two directed arcs. Then, each node \(v \in V{\setminus }\{i,j\}\) is replaced by an arc \((v',v'')\) whose capacity is defined as \(\tilde{y}_v\), all arcs entering v are now directed into \(v'\), and all arcs leaving v are now directed out of \(v''\). Capacities of these arcs are set to \(\infty \). Since all arcs except the nodearcs are of infinite capacity, the maximum (i, j)flow returns the desired violated connectivity constraint.
According to our computational experience, however, the above procedure is rather time consuming (all terminal pairs need to be considered, and for each pair, the maximum flow is calculated). As there is always a certain tradeoff between the quality of lower bounds obtained by separating fractional points and the associated computational effort, we refrain from the separation of fractional points in our default implementation.
Consequently, to ensure the validity of our branchandcut approach, we need to cut off infeasible integer points enumerated during the branching procedure (or detected by the heuristics of the MIP solver, given that the solver was not provided a complete information about the structure of the problem). Infeasible points are cut off by means of a LazyCutCallback in our setting based on the commercial MIP solver IBM ILOG CPLEX. For a given pair of distinct terminal nodes \(i,j \in T\) such that \(\tilde{y}_i = \tilde{y}_j = 1\), our separation procedure runs in linear time (with respect to E) and works as outlined below.
To derive our algorithm, we use the following wellknown property of node separators (see, e.g., [18]):
Lemma 1
Let \(N \in \mathscr {N}(i,j)\) be an (i, j)separator for \(i,j \in T\), \(i \ne j\), and let \(C_i\) and \(C_j\) be connected components of \(G  N\) such that \(i \in C_i\), \(j \in C_j\). Then N is a minimal (i, j) node separator iff every node in N is adjacent to at least one node in \(C_i\) and to at least one node in \(C_j\).
In practice, set \(R_j\) can be found by just running a standard BreadthFirst Search (BFS) on the original graph G, starting from node j, with the additional rule that nodes in \(A(C_i)\) are never put in the BFS queue.
Proposition 1
Algorithm 1 returns a minimal separator \(N \in \mathscr {N}(i,j)\) in time O(E).
Proof
By definition of N, i and j are not connected in \(G  N\). To see that N is a minimal (i, j)separator, consider \(G  N\) and let \(C'_i\) and \(C'_j\) be two connected components, containing i and j, respectively. Clearly, \(C_i \subset C'_i\) and \(C'_j=R_j {\setminus } N\). Hence, by Lemma 1, it follows that N is minimal. \(\square \)
In case \(p>2\) connected components exist in \(G_{\tilde{y}}\) (each of them containing at least one terminal), one can repeat the procedure described in Algorithm 1 for each pair of distinct components \(C_i\) and \(C_j\).
3 Algorithmic framework
The proposed nodebased model can be solved by means of a branchandcut (B&C) algorithm, to be initialized with a highquality feasible solution and with a suitable set of relevant connectivity constraints.
Our initial MIP model, called the basic model in what follows, is made by (7), (9), (10), plus the nodedegree inequalities (11) and the 2cycle inequalities (12).
The overall algorithmic framework is shown in Algorithm 2. In an initialization phase, an initial solution pool \(\mathscr {S}_\mathrm {init}\) is generated by means of some problemdependent heuristics. In a subsequent local branching phase, multiple calls of the B&C algorithm are used to explore the neighborhood of starting solutions chosen from the solution pool \(\mathscr {S}_\mathrm {init}\). All connectivity constraints separated during this phase are globally valid, hence they are stored in a global cut pool \( CutPool \), and added to the initial MIP model before each B&C reexecution. The incumbent solution (denoted by \( Sol \)) is updated correspondingly. A detailed description of the LocalBranching procedure and of its parameters is given in Sect. 3.1.
The local branching phase implements a multiple restart policy (with different seed values and a maximum number of iterations \( LBMaxRestarts \)), intended to gather relevant information about the problem at hand, namely good primal solutions and a relevant set of connectivity constraints; see e.g. [16] for a recent application of multiple restarts to MIPs with uncertainty. The availability of such information at the root node of each B&C reexecution turns out to be very important, as it triggers a more powerful preprocessing as well as the generation of a bunch of useful generalpurpose cuts (in particular, \(\{0,1/2\}\)cuts [3, 6]) based on the problem formulation explicitly available on input.
The algorithm terminates after proving the optimality, or after reaching the given time limit.
3.1 Local branching
Local branching (LB) has been proposed in [15] as a solution approach that uses the power of a generalpurpose MIP solver as a black box to strategically explore promising solution subspaces. LB is in the spirit of largeneighborhood search metaheuristics, with the main difference that the underlying local search blackbox algorithm is a MIP with a specific local branching constraint that restricts the search for an optimal solution within a certain neighborhood of a given reference solution.
The LB framework is built on top of our B&C solver. As already mentioned, our solver deals with two sets of inequalities: those in the basic model, that are always part of the model, and connectivity constraints (8) that are dynamically separated and stored in a global \( CutPool \) to be used in every subsequent B&C call.
Notice that, for a fixed radius, the neighborhood of the asymmetric version is larger and leads to potentially better solutions—though it is more time consuming to explore. For example, for \(r= 0\) the asymmetric version is equivalent to fixing to 1 all the variables from \( Sol \), so that many feasible solutions are still available even in the 0neighborhood around \( Sol \). After some preliminary tests, we decided to use the asymmetric LB constraint (13) in our implementation, with a small radius r ranging from 10 to 30. Working with a small radius is indeed crucial for the success of proximity methods such as LB, as recently pointed out in [17].
The LB framework is shown in Algorithm 3. Since the goal of the B&C in this context is to quickly find highquality solutions, we do not necessarily search for an optimal solution within the given neighborhood, but we rather impose limits on the number of incumbent solutions found (\( LBSolLim \)), and a time limit per iteration (\( LBTimeLim \)).
3.2 Benderslike (set covering) heuristic
In our experiments, we found that the above approach works very well for uniform STP instances of very large size, for which the standard MIP approach seems not very appropriate as even the LP relaxation of the model takes an exceedingly large computing time to be solved. Our setcovering based heuristic is an implementation of Algorithm 4 for these hard instances, and is based on their set covering interpretation. Indeed, as already observed, the basic model turns out to be a compact set covering problem where columns correspond to Steiner nodes, rows to real terminals not adjacent to any other real terminal, and column j covers row i iff \(\{i,j\}\in E\). The approach can be outlined as follows.
At each iteration of the while loop, the relaxation to be heuristically solved is constructed through a procedure that automatically extracts a set covering relaxation from the current model. This is done by simply (1) projecting all fixed variables (including y variables for hard terminals) out of the model, and (2) skipping all constraints, if any, that are not of type \(y(S) \ge 1\) for some node set S.
We then proceed by heuristically solving the set covering relaxation through an implementation of the Caprara–Fischetti–Toth (CFT) heuristic [7, 8]. This is a very efficient set covering heuristic based on Lagrangian relaxation, that is specifically designed for hard/large instances.
Given a hopefully good set covering solution \( Sol ^R\), we repair it in a very aggressive way by introducing a local branching constraint in asymmetric form with radius \(r=0\), and then by applying our B&C solver (with its adhoc connectivity cut separation) with a short time/node limit. As already observed, this local branching constraint in fact corresponds to fixing \(y_j=1\) for all j such that \( Sol ^R_j=1\). As a result, the size/difficulty of the MIP model after fixing is greatly reduced, hence the node throughput of the B&C solver becomes acceptable even for large instances—while setting a larger radius would not result in a comparable speedup.
All violated connectivity cuts generated by the B&C procedure are added to \( CutPool \) and hence to the current model. This makes solution \( Sol ^R\) (if disconnected) infeasible even for the next set covering relaxation and thus the procedure can be iterated until an overall time/iteration limit is reached.

the procedure that extracts the set covering model makes a random shuffle of the rows/columns, so as to affect in a random way the performance of the CFT heuristic;

before the repairing phase, we randomly skip (with a uniform probability of 20 %) some variable fixings, meaning that approximately 80 % of the variables \(y_j\)’s with \( Sol ^R_j=1\) are actually fixed.
Finally, we observe that our current CFT implementation is sequential and cannot exploit multiple processors. We therefore decided to also run the refining B&C in singlethread mode, thus obtaining an overall sequential code that can be run in parallel and with different random seeds on each single core (in the multithread mode). The best found solution is finally returned.
This Benderslike heuristic is embedded in the overall algorithmic framework shown in Algorithm 2 as InitializationHeuristics for uniform STP instances on bipartite graphs with a large percentage of terminals. Indeed, these kinds of graphs are very regular and the basic model likely gives a reasonable approximation of the STP problem—in the sense that most connectivity constraints are automatically satisfied. In addition, the whileloop in Algorithm 2 that would apply standard local branching after the setcovering based heuristic is unlikely to be effective for these graphs, so we set \( LBMaxIter =0\) and skip it in this case.
We conclude this section by observing that the “relaxation” to be heuristically solved in the Benderslike scheme is not intended to produce valid dual bounds, as its purpose is to feed the refining procedure with good (possibly disconnected) solutions. As a matter of fact, one can think of the relaxation as a “blurred” version of the original problem, which retains some of its main features but is not bothered by too many details (namely, connectivity conditions) that would overload the model. Following this general idea, we implemented the following variant of our setcovering based heuristic, which is intended for nonuniform instances on bipartite graphs with a large percentage of terminals.
Given a nonuniform instance of the STP, it is transformed to a uniform instance by adapting its revenue and edge costs as follows: For each nonterminal \(v \in V {\setminus } T_r\), its node cost \(\tilde{c}_v\) is set to the average cost of its incident edges, i.e., \(\tilde{c}_v=\frac{1}{\delta (v)}\sum _{e\in \delta (v)} c_e\). Next, all edge costs and node revenues are set to zero. Intuitively, edge cost information is moved into node costs, so as to get a “blurred” uniform instance on the same underlying graph. Note that these modified costs/revenues are only used within the CFT heuristic, while the original ones are used in the refining phase.
3.3 Implementation details of the (x, y)model
The model described in Sect. 1 has been implemented together with several algorithmic enhancements, which are detailed in the following paragraphs.
Initialization heuristic A pool of initial feasible solutions is constructed as follows. Several terminals are chosen as root nodes, for each of which a solution is calculated by applying the shortest path Steiner tree heuristic (see, e.g., [4]). In the PCSTP case, for a small number of iterations the set \(T_p \cup T_r\) is perturbed and subsets of terminals of different size are considered as fixed terminals \(T'\). Then for each chosen set \(T'\), the same construction heuristic as for the STP is applied. Each solution is also improved through a local search (see below).
For sparse, (almost) planar nonuniform instances of the STP, our framework computes an additional, enhanced initial solution by applying a parallel variant of the partitioning heuristic described in [21]. Based on a randomly chosen solution from the pool, the input graph is partitioned into a set of smaller subgraphs (containing terminals and their closest Steiner nodes). The STP is then solved to optimality (or with a small time limit) on each of these subgraphs independently. The obtained disconnected (and thus, infeasible) solution is then repaired by a shortestpath like heuristic, followed by a local search. When run in a multithread mode, solving the STP on each of the subgraphs is assigned to a single thread.
Primal heuristic We apply a few rounds of rounding on the set of y variables, with different threshold values. Rounded up variables again define a set of fixed terminals \(T'\) on which we run the shortest path Steiner tree heuristic (with a modified cost function that reflects the LPvalues at the current branchandbound node) and prune Steiner leaves.
Local search heuristics Solutions obtained by the initialization or the primal heuristic are further improved by applying several local search procedures: keypathexchange, (key)noderemoval and nodeinsertion. For further implementation details about these heuristics, see [25]. We only accept strictly improving moves, except for uniform and almost uniform instances, for which (due to existence of many symmetric solutions) all moves with nonincreasing objective values are performed. An instance is considered as almost uniform if the absolute difference between the minimum and maximum edge weight is less than ten.
Additional valid inequalities In [22] the authors observe that the (x, y)model for PCSTP contains a lot of symmetries, and propose to get rid of them by fixing the terminal node with the smallest index (among those taken in the solution) to be the root node. This is imposed by adding additional asymmetry constraints. The latter constraints added by [22] were given in a disaggregated form, whereas in our implementation we add their stronger, aggregated variant: \(\sum _{i > j} x_{ri} \le 1  y_j\), for all \(j \in T\). We also add 2cycle inequalities (12) to our starting model.
To further speed up separation, we skip the maximum flow calculation for terminals that are already reachable from the root in the support graph (node set W in the algorithm). We do not separate cuts recursively [22, 23], but instead separate at most one connectivity constraint for each terminal per iteration. Avoiding the separation of fractional solutions while branching and adding only one cut per terminal seemed to perform best on average in preliminary experiments.
For the PCSTP we only separate cuts between the root and those terminals i such that \(y_i \ge 0.5\) in the given fractional solution to separate. Furthermore, instead of adding a connectivity constraint (3) as in [22], we may replace the righthand side with one if the revenue on the sink side of the cut is larger than the objective of the incumbent solution. This implies that in an optimal solution, at least one more node on the sink side has to be connected to the root.
Infeasible integer solutions are separated by searching for connected components in the support graph. For each subset S inducing a connected component of an infeasible solution, a connectivity constraint \(x(\delta ^(S)) \ge y_i\) is added to the model, for \(i \in S\) with the highest revenue.
3.4 A unified solver and automatic parameter adjustments
Instance properties identified by the filter procedure
Property  Description 

uniform  All arc weights have the same weight 
sparse  Edgetoarc ratio \(E/V \le 3\) 
dense  Edgetoarc ratio \(E/V > 3\) 
verydense  Edgetoarc ratio \(E/V > 5\) 
ratioT  Terminal ratio T / V 
big  Number of nodes \(V > 10{,}000\) 
small  Number of nodes \(V < 1000\) 
hypercube  All nodes have the same degree 
stp  Problem instance is of type STP 
xymodel  The (x, y)model has been selected by the filter 
bipartite  The instance graph G is bipartite w.r.t. the node sets \(V {\setminus } T\) and T 
General filter rules
Rule  Applied settings  

\(\texttt {uniform}\)  \(\wedge (\lnot \texttt {sparse} \vee \texttt {ratioT} \ge 0.1)\)  \(\rightarrow \,y\hbox {model}\) 
\(\texttt {uniform}\)  \(\wedge \texttt {sparse}\wedge \texttt {ratioT} < 0.1\)  \(\rightarrow \,(x,y)\hbox {model}\) 
\(\lnot \texttt {uniform}\)  \(\rightarrow \,(x,y)\hbox {model}\)  
\(\texttt {dense}\)  \(\rightarrow \,\) Use tailingoff bound, high tolerance  
\(\texttt {verydense}\)  \(\rightarrow \,\) Use tailingoff bound, low tolerance 
Table 2 lists general filter rules for model and parameter selection. By default, the ymodel is applied to instances with uniform edge costs, while the (x, y)model is applied to all others. For sparse, uniform graphs with a relatively low number of terminals, we switch to the (x, y)model, as preliminary experiments have shown that the ymodel is less efficient for this specific class. For the ymodel, the MIP at the root node is restarted two times in order to generate more general purpose cutting planes, since the cutting plane generation procedures of CPLEX for such cuts are triggered again after a restart and produce additional cuts.
For the (x, y)model a tailingoff bound is specified, which defines the allowed ratio between the lower bounds of two consecutive B&C iterations in the root node. In addition, a tailingoff tolerance value is defined, which specifies the number of times this bound is allowed to be violated in a row. If the number of violations exceeds the specified toleranceparameter, the algorithm switches from separation of fractional solutions to branching. The two parameters are chosen based on graph density. Instances are roughly divided into two classes, sparse (\(E/V \le 3\)) and dense (\(E/V > 3\)) graphs. The tailingoff bound is only activated for dense graphs, while for sparse graphs we avoid branching as long as possible. In addition, we identify very dense (\(E/V > 5\)) instances, in which we set a lower tailingoff tolerance than in the regular case.
STPspecific rules
Rule  Applied settings  

\(\texttt {xymodel}\)  \(\wedge \texttt {ratioT} < 0.01\)  \(\rightarrow \,\) Separate dual ascent cuts  
\(\texttt {xymodel}\)  \(\wedge \texttt {ratioT} \ge 0.01\)  \(\rightarrow \,\) Add all dual ascent cuts  
\(\texttt {xymodel}\)  \(\wedge \texttt {ratioT} < 0.1\)  \(\wedge \texttt {sparse}\wedge \texttt {big}\)  \(\rightarrow \,\) Separate flowbalance constr., GSECs of size 2 
\(\texttt {xymodel}\)  \(\wedge \texttt {big}\)  \(\wedge \texttt {sparse}\)  \(\rightarrow \,\) Partitionbased construction heuristic 
\(\texttt {verydense}\)  \(\rightarrow \,\) Preprocessing (special distance test) 
Initialization heuristic rules
Rule  Applied settings  

\(\texttt {bipartite}\)  \(\wedge \,\texttt {uniform}\)  \(\rightarrow \,\) Setcovering heuristic 
\(\texttt {bipartite}\)  \(\wedge \,\lnot \texttt {uniform}\,\wedge \quad \texttt {stp}\)  \(\rightarrow \,\) Blurred setcovering heuristic 
\(\texttt {hypercube}\)  \(\wedge \,\lnot \texttt {uniform}\,\wedge \,\lnot \,\texttt {small}\,\wedge \,\texttt {pcstp}\)  \(\rightarrow \,\) Blurred setcovering heuristic 
\(\lnot \texttt {bipartite}\)  \(\rightarrow \) Local branching 
Table 4 lists additional rules for the selection of initialization heuristics. In the case of bipartite graphs, the setcovering heuristic is applied for both uniform and nonuniform instances to generate highquality starting solutions. For nonuniform instances, each node v is assigned the weight \(\frac{1}{\delta (v)}\sum _{e \in \delta (v)} c_e\) (“blurred” setcovering heuristic). We note that also in the case of PCSTP instances we choose to apply the blurred setcovering heuristic for the large nonuniform instances. A significant slowdown of the (x, y)model has been observed for larger instances, at which point the blurred setcovering heuristic performs better. By default, the following settings are also applied when executing local branching: The primal heuristic is executed in every branchandbound node for the (x, y)model and in each 1000 nodes for the ymodel. The GSECs of size two in the (x, y)model are separated and stored in the cut pool. The local branching time limit per iteration is set to 120 s. The neighborhood radius is initialized with 10 and increased by 10 per iteration up to a maximum of 30.
4 Computational results
Our algorithms are applied to the following problems from the DIMACS challenge: STP, (rooted) PCSTP, MWCS, and also degreeconstrained STP (DCSTP). We begin by summarizing the results obtained on a set of hard (unsolved) cases of the SteinLib [20] instance library, and on a set of nontrivial MWCS instances posted on the DIMACS challenge website. The performance of the y and (x, y)model is compared given a 2h time limit (based on a single run per instance with fixed seed value). The filter from Sect. 3.4 is deactivated during these runs, to enable a barebone comparison between the models. Since on some of the tested datasets erratic performance could be observed during preliminary experiments, for these cases ten independent runs with different seeds have been performed, and the best and average running times are reported.
Detailed computational results, covering all nontrivial instances from the challenge are provided in the Appendix, ESM. Among these nontrivial instances, we distinguish between easy and difficult ones. For this purpose, we first run all considered instances using a pure B&C approach, for which the setcovering heuristic and local branching are deactivated. The filter rules listed in Tables 2 and 3 are applied and a time limit of 1 h (with a fixed seed value) is imposed. All instances that remained unsolved by this approach are considered as difficult.
Our heuristic framework (consisting of the initialization and local branching phase, see Algorithm 2) is then applied to all difficult instances with a time limit of 1 h (ten independent runs with different seeds).
The experiments were performed on a cluster of computers, each consisting of 20 cores (Intel E52670v2 2.5 GHz) and with 64GB RAM available for the 20 cores. Reported computing times are in wallclock seconds. To limit the overall time needed to complete our experiments, we decided to allow up to five simultaneous 4core runs on the same computer, which however implies a significant slowdown due to shared memory.
All algorithms have been implemented in C++ and compiled with GCC 4.9.2. For data structures we used OGDF [10, 24] and the dtree library [14]. CPLEX 12.6 was used as MIPsolver with an imposed memory limit of 12GB RAM.
4.1 Results for uniform STP instances GAPS and SP
Uniform STP instances from the GAPS dataset
Instance  \(V\)  \(E\)  \(T\)  ymodel  (x, y)model  

OPT  Time (s)  UB  LB  Gap (%)  Time (s)  
s1  64  192  32  10  0.0  10  10  0.00  0.0 
s2  106  399  50  73  0.0  73  73  0.00  1.4 
s3  743  2947  344  514  0.2  514  505  1.78  1090.6\(\mathrm{^a}\) 
s4  5202  20,783  2402  3601  1.3  3601  3523  2.21  3444.8\(\mathrm{^a}\) 
s5  36,415  145,635  16,808  25,210  22.3  25,210  24,056  4.80  7200.0 
Uniform STP instances from the SP dataset
Instance  V  E  T  OPT  ymodel  (x, y)model  

Time (s)  Time (s)  
BEST  AVG  STD  BEST  AVG  STD  
w13c29  783  2262  406  507 (508)  0.3  0.9  0.5  14.5  38.3  30.0 
w23c23  1081  3174  552  689 (694)  43.9  132.6  60.0  183.9  2600.2  1362.6 
4.2 Results for MWCS instances
The MWCS can be transformed into the PCSTP with uniform edge costs (see [2]). We have tested both y and (x, y)model on the MWCS dataset, and the obtained computational results (for the most challenging instances) are reported in Table 7 for ten different seed values. Results on the JMPALMK dataset are available in the Appendix, ESM—these instances have all been solved within 1 s.
ACTMOD instances from the DIMACS website
Instance  V  \(E\)  T  OPT  ymodel  (x, y)model  

Time (s)  Time (s)  
BEST  AVG  STD  BEST  AVG  STD  
HCMV  3863  29,293  3863  7.554315  1.3  1.5  0.2  6.5  7.6  0.8 
drosophila001  5226  93,394  5226  24.385506  10.6  12.2  1.3  93.9  181.9  86.8 
drosophila005  5226  93,394  5226  178.663952  12.2  13.2  0.9  120.9  184.9  57.6 
drosophila0075  5226  93,394  5226  260.523557  9.4  10.6  1.1  105.3  168.0  65.1 
lymphoma  2034  7756  2034  70.166309  0.3  0.4  0.0  1.2  1.3  0.0 
mice_1  3523  4345  3523  544.948370  2748.7  4697.9  1749.8  1.2  1.6  0.4 
mice_2  3514  4332  3514  241.077524  1.0  1.4  0.3  1.1  1.1  0.1 
mice_3  2853  3335  2853  508.260877  3.6  5.4  1.5  0.8  0.9  0.1 
4.3 Results for STP and PCSTP instances
STP PUC instances solved by the pure B&C with parameters chosen automatically by the filter procedure (ymodel for hc6u, hc7u, bip42u, bipe2u; (x, y)model for all others)
Instance  \(V\)  \(E\)  \(T\)  LB  UB  Gap (%)  Nodes  Time (s)  Timet (s) 

bip42u  1200  3982  200  236  236  0.00  1,603,599  466.5  1038.0 
bipe2p  550  5013  50  5616  5616  0.00  4333  59.1  76.0 
bipe2u  550  5013  50  54  54  0.00  123  0.1  0.5 
cc34p  64  288  8  2338  2338  0.00  45,113  1.0  43.9 
cc34u  64  288  8  23  23  0.00  4224  0.0  7.4 
cc53u  243  1215  27  71  71  0.00  220,216  0.6  1940.3 
cc62p  64  192  12  3271  3271  0.00  694  2.6  13.8 
cc62u  64  192  12  32  32  0.00  108  0.0  17.0 
cc63u  729  4368  76  197  197  0.00  10,814  371.1  389.9 
hc6p  64  192  32  4003  4003  0.00  4004  0.3  2.1 
hc6u  64  192  32  39  39  0.00  1142  0.1  0.2 
hc7u  128  448  64  77  77  0.00  816,615  0.1  1372.7 
For the remaining, more difficult instances, Tables 9, 10, 11, 12, 13, 14 list the most important results after applying the setcovering heuristic or local branching. These datasets have been selected from the set of instances unsolved after 1 h by B&C (detailed results are available in the Appendix, ESM). Each run has been computed by starting the algorithm with ten different seeds, each with 1 h time limit. The choice between the local branching and setcovering heuristic is performed by the filter as described in Sect. 3.4. The final B&C step of the framework is always skipped.
Each table is structured as follows: the first four columns list the instance name, the number of nodes, edges and terminals. The next pair of columns (BEST) shows objective value and time of computation for the best found solution. The following pairs (AVG and STD) list the average and standard deviation of these two values over all ten runs. For tests on previously known STP datasets (PUC, I640) the column ‘Impr.’ lists the improvement w.r.t. the best known published solution (by August 1st, 2014) according to the DIMACS challenge website [11]. In all other cases, the improvement is given w.r.t. the best primal solutions produced during the exact runs after 1 h. As is to be expected, given the same time limit, the heuristic procedures manage to outperform the pure B&C with respect to the computed upper bounds. The comparison on notoriously difficult instances for the STP (PUC and I640, Tables 9, 10) particularly emphasizes the heuristics’ effectiveness, as several of the previously known upper bounds could be improved. The most noticeable and consistent improvement can be observed for the hypercube instances, to which the setcovering heuristic has been applied.
Problem  Instance  Best UB  Previous UB  Time (s)  #Threads 

STP  hc11u  1144  1154  474  8 
STP  hc12u  2256  2275  4817  8 
STP  hc12p  236,158  236,949  4411  4 
PCSTP  hc12u2  1492  –  632  16 
PUC STP instances
Instance  \(V\)  \(E\)  \(T\)  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
bip42p  1200  3982  200  24,657  38.4  24,660.8  664.6  2.0  1125.2  0 
bip52p  2200  7997  200  24,549  805.6  24,566.9  1403.0  13.9  1357.4  \(\)14 
bip52u  2200  7997  200  233  1390.1  233.8  287.9  0.4  598.0  1 
bip62p  1200  10,002  200  22,906  3.6  22,907.0  55.4  1.1  80.8  \(\)36 
bip62u  1200  10,002  200  219  6.2  219.0  12.3  0.0  5.0  1 
bipa2p  3300  18,073  300  35,355  547.2  35,360.9  1342.9  4.4  879.6  24 
bipa2u  3300  18,073  300  337  185.1  337.0  310.9  0.0  215.2  4 
cc102p  1024  5120  135  35,257  875.4  35,353.2  704.9  75.1  705.2  122 
cc102u  1024  5120  135  342  206.3  342.6  818.0  0.5  1078.2  0 
cc112p  2048  11,263  244  63,680  744.3  63,895.7  976.4  103.4  726.6  146 
cc112u  2048  11,263  244  615  1388.7  616.9  1203.8  1.0  951.6  \(\)1 
cc122p  4096  24,574  473  122,166  1884.1  123,096.0  1912.6  468.0  799.1  \(\)1060 
cc122u  4096  24,574  473  1183  1559.5  1186.3  1937.0  1.8  804.2  \(\)4 
cc310p  1000  13,500  50  12,784  3471.2  12,826.2  1801.6  43.5  1139.7  76 
cc310u  1000  13,500  50  125  61.9  125.0  615.8  0.0  683.5  0 
cc311p  1331  19,965  61  15,599  458.9  15,633.3  812.1  35.4  965.1  10 
cc311u  1331  19,965  61  153  29.7  153.0  269.3  0.0  580.9  0 
cc312p  1728  28,512  74  18,879  1290.1  18,936.6  1771.1  31.5  1139.8  \(\)41 
cc312u  1728  28,512  74  185  59.7  185.0  900.5  0.0  985.4  1 
cc35p  125  750  13  3661  0.8  3661.0  10.5  0.0  13.2  0 
cc35u  125  750  13  36  0.0  36.0  0.0  0.0  0.0  0 
cc53p  243  1215  27  7299  16.4  7299.0  238.2  0.0  208.6  0 
cc63p  729  4368  76  20,340  1266.8  20,395.9  1544.0  46.0  984.0  116 
cc73p  2187  15,308  222  57,080  1385.5  57,328.7  1197.7  153.9  888.0  8 
cc73u  2187  15,308  222  551  383.8  554.1  1267.2  1.5  1078.5  1 
cc92p  512  2304  64  17,202  1603.4  17,274.4  1579.8  28.5  984.4  94 
cc92u  512  2304  64  167  15.0  167.3  753.1  0.5  1018.6  0 
hc7p  128  448  64  7905  2480.0  7915.8  875.6  6.0  746.9  0 
hc8p  256  1024  128  15,337  2494.8  15,349.5  1057.5  7.5  1128.9  \(\)15 
hc8u  256  1024  128  148  0.0  148.0  0.1  0.0  0.0  0 
hc9p  512  2304  256  30,319  1232.0  30,342.3  1824.9  14.1  777.7  \(\)61 
hc9u  512  2304  256  292  0.3  292.0  0.4  0.0  0.1  0 
hc10p  1024  5120  512  59,981  267.5  60041.3  1013.5  33.4  817.0  513 
hc10u  1024  5120  512  575  11.2  575.0  87.0  0.0  85.9  6 
hc11p  2048  11,264  1024  119,500  3327.8  119,533.0  1708.9  35.1  1129.1  279 
hc11u  2048  11,264  1024  1145  663.3  1145.4  1319.2  0.5  873.1  9 
hc12p  4096  24,576  2048  236,267  2782.9  236,347.1  2514.0  55.4  565.3  682 
hc12u  4096  24,576  2048  2261  2756.8  2262.5  2805.2  1.3  747.0  14 
I640 STP instances
Instance  V  E  T  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
i640311  640  4135  160  35,766  117.6  35,779.0  1521.0  21.7  1219.7  0 
i640312  640  4135  160  35,768  1410.3  35,793.2  1478.5  25.4  1104.3  3 
i640313  640  4135  160  35,535  292.6  35,538.2  923.7  4.1  921.4  0 
i640314  640  4135  160  35,533  1610.0  35,547.0  1673.7  12.5  679.5  5 
i640315  640  4135  160  35,720  156.2  35,733.5  866.8  21.9  695.9  21 
PUCN STP instances (uniform version of the PUC codecoverage dataset)
Instance  \(V\)  \(E\)  \(T\)  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
cc102n  1024  5120  135  180  89.5  181.0  690.1  0.7  952.4  2 
cc112n  2048  11,263  244  327  39.8  328.0  658.6  0.7  904.0  4 
cc122n  4096  24,574  473  617  930.4  621.8  933.1  2.6  639.2  9 
cc310n  1000  13,500  50  75  0.3  75.0  1.2  0.0  1.0  0 
cc311n  1331  19,965  61  92  0.5  92.0  1.2  0.0  0.8  0 
cc312n  1728  28,512  74  111  2.1  111.0  6.6  0.0  3.8  0 
cc73n  2187  15,308  222  290  51.4  290.7  449.6  0.8  410.3  3 
cc92n  512  2304  64  98  73.5  98.9  598.7  0.6  575.5  2 
PUCNU PCSTP instances (uniform PCSTP version of the PUC dataset)
Instance  V  \(E\)  \(T\)  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
bipa2nu  3300  18,073  300  324  18.0  324.0  534.2  0.0  580.8  1 
cc102nu  1024  5120  135  168  253.0  169.2  1059.5  0.6  1140.6  3 
cc112nu  2048  11,263  244  305  158.5  306.5  612.7  1.3  563.0  7 
cc122nu  4096  24,574  473  568  1427.2  571.0  921.5  1.5  893.8  13 
cc310nu  1000  13,500  50  61  0.5  61.0  4.2  0.0  5.6  0 
cc311nu  1331  19,965  61  79  11.6  79.3  365.4  0.5  571.8  1 
cc312nu  1728  28,512  74  95  12.2  95.0  412.3  0.0  538.5  1 
cc73nu  2187  15,308  222  271  565.0  274.1  639.5  1.3  751.4  9 
H and H2 PCSTP instances
Instance  \(V\)  \(E\)  \(T\)  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
hc8p  256  1024  256  15,206  537.3  15,228.5  1514.8  15.7  1234.1  58 
hc9p  512  2304  512  30,043  3062.5  30,084.0  1967.6  25.2  1073.5  209 
hc10p  1024  5120  1024  59,866  919.1  59,965.2  1078.3  46.4  922.7  728 
hc10u  1024  5120  1024  559  2349.4  559.9  773.6  0.3  1081.3  3 
hc11p  2048  11,264  2048  119,191  3600.0  119,377.6  1851.1  96.4  1114.0  1806 
hc11u  2048  11,264  2048  1116  2284.5  1117.2  1568.6  0.8  1193.9  4 
hc12p  4096  24,576  4096  235,860  2542.6  236,103.4  2417.0  147.2  685.5  4621 
hc12u  4096  24,576  4096  2221  310.5  2223.1  1078.5  1.4  1035.8  5 
hc8p2  256  1024  256  15,231  178.3  15,255.0  1271.7  17.8  996.9  60 
hc9u2  512  2304  512  190  10.0  190.0  15.4  0.0  3.0  0 
hc10p2  1024  5120  1024  59,930  2119.8  59,966.4  1849.7  21.5  983.5  601 
hc10u2  1024  5120  1024  380  47.7  380.3  1287.8  0.5  1119.2  2 
hc11p2  2048  11,264  2048  119,236  330.5  119,381.8  1106.5  89.7  704.0  1762 
hc11u2  2048  11,264  2048  750  2009.5  751.4  1596.3  0.7  1131.7  11 
hc12p2  4096  24,576  4096  235,687  3172.9  235,985.0  2099.7  217.3  1076.0  4793 
hc12u2  4096  24,576  4096  1494  101.9  1494.1  671.8  0.3  1031.3  13 
I640 PCSTP instances
Instance  V  \(E\)  T  BEST  AVG  STD  Impr.  

UB  Time (s)  UB  Time (s)  UB  Time (s)  
i640311  640  4135  160  33,503  1062.2  33,518.8  2045.0  20.4  1093.3  44 
i640312  640  4135  160  32,721  152.9  32,721.0  1846.1  0.0  1147.9  69 
i640313  640  4135  160  32,401  200.1  32,403.0  1302.3  6.3  906.8  0 
i640314  640  4135  160  32,871  1572.9  32,893.1  1590.9  20.4  1147.9  88 
i640315  640  4135  160  32,616  491.3  32,631.3  1621.2  9.3  1059.4  50 
i640321  640  204,480  160  28,787  309.3  28,788.3  1121.0  1.6  1234.3  16 
i640322  640  204,480  160  28,458  943.7  28,461.2  989.0  3.9  828.9  9 
i640323  640  204,480  160  28,153  9.2  28,153.5  667.8  0.5  687.5  4 
i640324  640  204,480  160  28,746  44.5  28,747.5  864.6  1.0  1116.1  14 
i640325  640  204,480  160  28,385  31.3  28,386.0  1588.6  0.9  1589.0  1 
i640341  640  40,896  160  29,702  1585.8  29,720.5  1679.1  14.2  984.2  37 
i640342  640  40,896  160  29,806  1591.9  29,828.8  1889.1  16.8  915.5  32 
i640343  640  40,896  160  30,056  307.3  30,059.9  1093.9  8.2  691.1  0 
i640344  640  40,896  160  29,921  365.2  29,943.8  1370.6  12.8  913.1  21 
i640345  640  40,896  160  30,004  2580.5  30,029.6  2289.4  18.7  1141.9  78 
Problem  Instance  OPT  Time (s)  #Threads  #Memory (GB) 

STP  i640313  35,535  16,012  20  32 
PCSTP  i640313  32,401  15,358  20  32 
Furthermore, we were able to prove optimality for the following difficult instances, where according to the SteinLib website [20] the instances i640313 has previously been unsolved (for the PCSTP version of i640313, we report similar performance):
5 Conclusions
We have presented a simple model for the Steiner tree problem, involving only node variables. Besides drastically reducing the number of the required variables, the removal of edge variables avoids a number of issues related to equivalent (possibly symmetrical) trees spanning a same node set. In this view, we are “thinning out” the usual edgebased model with the aim of getting a more agile framework. Our model is mainly intended for instances with uniform edge costs, but one could use it to derive a heuristic for tackling the general case (left for future studies). Computational results show that our approach can dramatically improve the performance of an exact solver, and in some cases converts very hard problems into trivialtosolve ones. At the recent DIMACS challenge on Steiner trees (see [12]), the proposed algorithmic framework, which switches intelligently between the model involving only nodevariables and a second model that uses both node and edge variables, won most of the categories of both, exact and heuristic challenge, for the STP, PCSTP, MWCS and DCSTP.
Footnotes
 1.
For instance hc12u2, no upper bounds have been reported before the challenge.
Notes
Acknowledgments
Open access funding provided by University of Vienna.
Supplementary material
References
 1.11th DIMACS Implementation Challenge in Collaboration with ICERM: Steiner tree problems (2014). http://dimacs11.zib.de/home.html. Accessed 20 Sept 2016
 2.ÁlvarezMiranda, E., Ljubić, I., Mutzel, P.: The maximum weight connected subgraph problem. In: Facets of Combinatorial Optimization: Festschrift for Martin Grötschel, pp. 245–270. Springer, Berlin (2013)Google Scholar
 3.Andreello, G., Caprara, A., Fischetti, M.: Embedding \(\{\)0, 1/2\(\}\)cuts in a branchandcut framework: a computational study. INFORMS J. Comput. 19(2), 229–238 (2007)MathSciNetCrossRefzbMATHGoogle Scholar
 4.de Aragão, M.P., Werneck, R.F.F.: On the implementation of MSTbased heuristics for the Steiner problem in graphs. In: Mount, D.M., Stein, C. (eds.) ALENEX. Lecture Notes in Computer Science, vol. 2409, pp. 1–15. Springer, London (2002)Google Scholar
 5.Backes, C., Rurainski, A., Klau, G.W., Müller, O., Stöckel, D., Gerasch, A., Küntzer, J., Maisel, D., Ludwig, N., Hein, M., Keller, A., Burtscher, H., Kaufmann, M., Meese, E., Lenhof, H.P.: An integer linear programming approach for finding deregulated subgraphs in regulatory networks. Nucleic Acids Res. 40, 1–13 (2012)CrossRefGoogle Scholar
 6.Caprara, A., Fischetti, M.: \(\{\)0, 1/2\(\}\)ChvátalGomory cuts. Math. Program. 74(3), 221–235 (1996)CrossRefzbMATHGoogle Scholar
 7.Caprara, A., Fischetti, M., Toth, P.: A heuristic algorithm for the set covering problem. In: Integer Programming and Combinatorial Optimization, pp. 72–84. Springer, Berlin Heidelberg (1996)Google Scholar
 8.Caprara, A., Fischetti, M., Toth, P.: A heuristic method for the set covering problem. Oper. Res. 47(5), 730–743 (1999)MathSciNetCrossRefzbMATHGoogle Scholar
 9.Cherkassky, B.V., Goldberg, A.V.: On implementing pushrelabel method for the maximum flow problem. Algorithmica. 19, 390–410 (1997)Google Scholar
 10.Chimani, M., Gutwenger, C., Jünger, M., Klau, G.W., Klein, K., Mutzel, P.: The open graph drawing framework (OGDF). In: Tamassia, R. (ed.) Handbook of Graph Drawing and Visualization, Chapter 17. CRC Press, Boca Raton (2014)Google Scholar
 11.Best bounds as of August 1, 2014 for SteinLib instances (2014). http://dimacs11.zib.de/instances/bounds20140801.txt. Accessed 20 Sept 2016
 12.Results of the 11th DIMACS Competition on Steiner Tree Problems (2015). http://dimacs11.zib.de/contest/results/results.html. Accessed 20 Sept 2016
 13.Duin, C.: Preprocessing the Steiner problem in graphs. In: Du, D.Z., Smith, J., Rubinstein, J. (eds.) Advances in Steiner Trees, Combinatorial Optimization, vol. 6, pp. 175–233. Springer, US (2000)Google Scholar
 14.Eisenstat, D.: dtree: dynamic trees à la carte (2014). http://www.davideisenstat.com/dtree/. Accessed 20 Sept 2016
 15.Fischetti, M., Lodi, A.: Local branching. Math. Progr. 98(1–3), 23–47 (2003)MathSciNetCrossRefzbMATHGoogle Scholar
 16.Fischetti, M., Monaci, M.: Cutting plane versus compact formulations for uncertain (integer) linear programs. Math. Progr. Comput. 4(3), 239–273 (2012)MathSciNetCrossRefzbMATHGoogle Scholar
 17.Fischetti, M., Monaci, M.: Proximity search for 0–1 mixedinteger convex programming. J. Heuristics 20(6), 709–731 (2014)CrossRefzbMATHGoogle Scholar
 18.Golumbic, M.C.: Algorithmic Graph Theory and Perfect Graphs (Annals of Discrete Mathematics), vol. 57. NorthHolland Publishing Co., Amsterdam (2004)Google Scholar
 19.Koch, T., Martin, A.: Solving Steiner tree problems in graphs to optimality. Networks 32(3), 207–232 (1998)Google Scholar
 20.Koch, T., Martin, A., Voß, S.: SteinLib: an updated library on Steiner tree problems in graphs. Tech. Rep. ZIBReport 0037, KonradZuseZentrum für Informationstechnik Berlin, Takustr. 7, Berlin (2000). http://elib.zib.de/steinlib
 21.Leitner, M., Ljubić, I., Luipersbeck, M., Resch, M.: A partitionbased heuristic for the Steiner tree problem in large graphs. In: Blesa, M.J., Blum, C., Voß, S. (eds.) Hybrid Metaheuristics—Proceedings. Lecture Notes in Computer Science, vol. 8457, pp. 56–70. Springer, UK (2014)Google Scholar
 22.Ljubić, I., Weiskircher, R., Pferschy, U., Klau, G.W., Mutzel, P., Fischetti, M.: An algorithmic framework for the exact solution of the prizecollecting Steiner tree problem. Math. Program. 105(2–3), 427–449 (2006)MathSciNetCrossRefzbMATHGoogle Scholar
 23.Lucena, A., Resende, M.G.: Strong lower bounds for the prize collecting Steiner problem in graphs. Discrete Appl. Math. 141(1), 277–294 (2004)MathSciNetCrossRefzbMATHGoogle Scholar
 24.OGDF: The Open Graph Drawing Framework (2015). http://www.ogdf.net/. Accessed 20 Sept 2016
 25.Uchoa, E., Werneck, R.F.: Fast local search for Steiner trees in graphs. In: Blelloch, G.E., Halperin, D. (eds.) ALENEX’10 Proceedings of the Meeting on Algorithm Engineering & Expermiments, pp. 1–10. SIAM (2010)Google Scholar
 26.Wang, Y., Buchanan, A., Butenko, S.: On imposing connectivity constraints in integer programs (2015). Submitted. Available at http://www.optimizationonline.org/DB_HTML/2015/02/4768.html
 27.Wong, R.T.: A dual ascent approach for Steiner tree problems on a directed graph. Math. Program. 28(3), 271–287 (1984)MathSciNetCrossRefzbMATHGoogle Scholar
Copyright information
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made.