Multi-Level Steiner Trees 1footnote 11footnote 1This material is based on work supported by the National Science Foundation through the TRIPODS project under Grant No. CCF-1423411. 2footnote 22footnote 2This paper has been accepted in 17th International Symposium on Experimental Algorithms (SEA 2018)

# Multi-Level Steiner Trees 12

## Abstract

In the classical Steiner tree problem, one is given an undirected, connected graph with non-negative edge costs and a set , the terminals. The objective is to find a minimum-cost edge set that spans the terminals. The problem is APX-hard [Bern & Plassman, IPL 1989]; the best known approximation algorithm has a ratio of [Byrka et al., J. ACM 2013]. In this paper, we study a natural generalization, the multi-level Steiner tree (MLST) problem: given a nested sequence of terminals , compute nested edge sets that span the corresponding terminal sets with minimum total cost. (Note that, for , edges in contribute ()-fold to this cost).

The MLST problem and variants thereof have been studied under names such as Quality-of-Service Multicast tree, Grade-of-Service Steiner tree, Multi-Tier tree, etc. Several approximation results are known. We first present two natural heuristics with approximation factor . Based on these, we introduce a composite algorithm that requires Steiner tree computations. We determine its approximation ratio by solving a linear program. We then present a method that guarantees the same approximation ratio and needs at most Steiner tree computations. We compare five algorithms experimentally on several classes of graphs using Erdős–Rényi, random geometric, Watts–Strogatz, and Barabási–Albert network generation models for varying , , and terminal selection methods. We also implemented an integer linear program for MLST to provide ground truth. Our combined algorithm outperforms the others both in theory and in practice when the number of levels is up to .

\setallmargins

1in

## 1 Introduction

Let be an undirected, connected graph with non-negative edge costs , and let be a set of vertices called terminals. A Steiner tree is a subgraph of  that spans . The (Network or Graph) Steiner tree problem () is to find a minimum-cost Steiner tree , where the cost of  is . STP is one of Karp’s initial NP-hard problems [12]. There is a survey on Steiner tree problems [22], an online compendium [11], and a textbook [19].

Due to its practical importance in many domains, there is a long history of exact and approximation algorithms for the problem. Let us quickly recall the classical 2-approximation algorithm for [10]. Consider the metric closure of , that is, the complete edge-weighted graph  with vertex set  in which, for every edge , the cost of  equals the length of a shortest path in . A minimum spanning tree of  corresponds to a 2-approximate Steiner tree in .

Currently, the last in a long list of improvements is the LP-based approximation algorithm of Byrka et al. [5], which has a ratio of . Their algorithm uses a new iterative randomized rounding technique. Note that is APX-hard [4]; more concretely, it is NP-hard to approximate the problem within a factor of  [7]. This is in contrast to the geometric variant of the problem, where terminals correspond to points in the Euclidean or rectilinear plane. Both variants admit polynomial-time approximation schemes (PTAS) [1, 15], while this is not true for the general metric case [4].

In this paper, we consider a natural generalization of where the terminals appear on “levels” and must be connected by edges of appropriate levels. We propose new approximation algorithms and compare them to existing ones both theoretically and experimentally.

###### Definition 1.1 (Multi-Level Steiner Tree (MLST) Problem).

Given a connected, undirected graph with edge weights and nested terminal sets , a multi-level Steiner tree consists of nested edge sets such that spans , , spans . The cost of an MLST is defined by . The MLST problem is to find an MLST with minimum cost.

Since the edge sets are nested, we can also express the cost of an MLST as follows:

 kc(E1)+(k−1)c(E2∖E1)+⋯+c(Ek∖Ek−1).

This emphasizes that the total cost of an edge that appears at level  is .

We denote the cost of an optimal MLST by . We can write

 OPT=kOPT1+(k−1)OPT2+⋯+OPTk

where and for . Thus represents the cost of edges on level but not on level in the minimum cost MLST. Figure 1 shows an example of an MLST for .

Applications.  This problem has obvious applications in designing multi-level infrastructures of low cost that connect users who need connections among themselves of high-enough quality for their purpose. Apart from this application in network design, multi-scale representations of graphs are useful in applications such as geography or network visualization, where users want to examine complex (street, river, or abstract) networks at different levels of detail. Here, the cost models the “stability” of the visualization.

Previous Work.  Variants of the MLST problem have been studied previously under various names, such as Multi-Level Network Design (MLND) [2], Multi-Tier Tree (MTT) [14], Quality-of-Service (QoS) Multicast Tree [6], and Priority-Steiner Tree [8].

In MLND, the vertices of the given graph are partitioned into levels, and the task is to construct a -level network. For , let be the cost of edge  if it is in level  (“primary” and “secondary” costs for 2 levels). The vertices on each level must be connected by edges of the corresponding level or higher, and edges of higher level are more costly, that is, for any edge . The cost of an edge partition is the sum of all edge costs, and the task is to find a partition of minimum cost. Note that the definitions of MLND and MLST treat the bottom level differently. While MLND requires that all vertices are connected eventually, this is not the case for MLST. In this respect, MLST is more general than MLND, which makes it harder to approximate. On the other hand, MLND is more flexible in terms of edge costs. Whereas the Steiner tree problem is a special case of the MLST problem for , the same problem is a special case of MLND for , by setting . Let  be the ratio of the best approximation algorithm for (single-level) , that is, currently . Balakrishnan et al. [2] gave a -approximation algorithm for 2-level MLND with proportional edge costs, that is, .

For MTT, which is equivalent to MLND, Mirchandani [14] presented a recursive algorithm that involves Steiner tree computations. For , the algorithm achieves an approximation ratio of independently of the edge costs . For proportional edge costs, Mirchandani’s analysis yields even an approximation ratio of for . Recall, however, that this assumes , and setting the edge costs on the bottom level to zero means that edge costs are not proportional.

In the QoS Multicast Tree problem [6] one is given a graph, a source vertex , and a level between 1 and  for each terminal (1 meaning important). The task is to find a minimum-cost Steiner tree that connects all terminals to . The level of an edge  in this tree is the minimum over the levels of the terminals that are connected to  via . The cost of the edges and of the tree are as above. As a special case, Charikar et al. [6] introduced what they call the rate model, where edge costs are proportional. They show that the rate model remains NP-hard if all vertices (except the source) are terminals (at some level). Note that if we choose as source any vertex at the top level , then the MLST problem can be formulated as an instance of the rate model by Charikar et al.

First, Charikar et al. gave a simple -approximation algorithm for the rate model. Given an instance , their algorithm constructs an instance  where the levels of all vertices are rounded up to the nearest power of 2. Then the algorithm simply computes a Steiner tree at each level of  and prunes the union of these Steiner trees into a single tree. Next, Charikar et al. improved the ratio to , where is the base of the natural logarithm. The -approximation is similar to the -approximation, but uses randomized doubling. It can be derandomized.

Instead of taking the union of the Steiner trees on each rounded level, Karpinski et al. [13] contract them into the source in each step. This yields a -approximation. Karpinski et al. also gave a -approximation for the 2-level case. (Since the results of Karpinski et al. are not given with respect to , but depend on several Steiner tree approximation algorithms – among them the best approximation algorithm with ratio 1.549 [20] available at the time – we obtained the numbers given here by dividing their results by 1.549 and stating the factor . Strictly speaking, their algorithm could perform worse when plugging in the algorithm of Byrka et al. [5], but we did not redo their analysis.)

For the more general Priority-Steiner Tree problem, where edge costs are not necessarily proportional, Charikar et al. [6] gave a -approximation algorithm. Chuzhoy et al. [8] showed that Priority-Steiner Tree does not admit an -approximation algorithm unless NPDTIME.

For Euclidean MLST, Xue at al. [24] gave a recursive algorithm that uses any algorithm for Euclidean Steiner Tree (EST) as a subroutine. With a PTAS [1, 15] for EST, the approximation ratio of their algorithm is for and for .

Our Contribution.  We introduce and analyze two intuitive approximation algorithms for MLST – bottom-up and top-down; see Section 2.1. The bottom-up heuristic uses a Steiner tree at the bottom level for the higher levels after pruning unnecessary edges at each level. The top-down heuristic first computes a Steiner tree on the top level. Then it passes edges down from level to level until the bottom level terminals are spanned.

We then propose a composite heuristic that generalizes these and examines all possible (partial) top-down and bottom-up combinations and returns the one with the lowest cost; see Section 2.2. We propose a linear program that finds the approximation ratio of the composite heuristic for any fixed value of . We compute the explicit approximation ratios for up to 22 levels, which turn out to be better than those of previously known algorithms. The composite heuristic requires, however, STP computations.

Therefore, we propose a procedure that achieves the same approximation ratio as the composite heuristic but needs only STP computations. In particular, it achieves a ratio of for levels, which settles a question posed by Karpinski et al. [13] who were asking whether the -approximation of Xue at al. [24] can be improved for . Note that Xue et al. treated the Euclidean case, so their ratio does not include the factor . We generalize an integer linear programming (ILP) formulation for STP [18] to obtain an exact algorithm for MLST; see Section 3. We experimentally evaluate several approximation and exact algorithms on a wide range of problem instances; see Section 4. The results show that the new algorithms are also surprisingly good in practice. We conclude in Section 5.

## 2 Approximation Algorithms

In this section we propose several approximation algorithms for MLST. In Section 2.1, we show that the natural approach of computing edge sets either from top to bottom or vice versa, already give -approximations; we call these two approaches top-down and bottom-up, and denote their cost by and , respectively. Then, we show that running the two approaches and selecting the solution with minimum cost produces a better approximation ratio than either top-down or bottom-up.

In Section 2.2, we propose a composite approach that mixes the top-down and bottom-up approaches by solving STP on a certain subset of levels, then propagating the chosen edges to higher and lower levels in a way similar to the previous approaches. We then run the algorithm for each of the possible subsets, and select the solution with minimum cost. For relatively small values of (), our results improve over the state of the art.

### 2.1 Top-down and Bottom-up approaches

We present top-down and bottom-up approaches for computing approximate multi-level Steiner trees. The approaches are similar to the MST and Forward Steiner Tree (FST) heuristics by Balakrishnan et al. [2]; however, we generalize the analysis to an arbitrary number of levels.

In the top-down approach, we compute an exact or approximate Steiner tree  spanning . Then we modify the edge weights by setting for every edge . In the resulting graph, we compute a Steiner tree  spanning the terminals in . This extends in a greedy way to span the terminals in not already spanned by . Iterating this procedure for all levels yields a solution with cost .

In the bottom-up approach, we compute a Steiner tree  spanning the terminals  in level . Then, for each level , we obtain as the smallest subtree of that spans all the terminals in , giving a solution with cost .

A natural approach is to run both top-down and bottom-up approaches and select the solution with minimum cost. This yields an approximation ratio better than those from top-down or bottom-up. Let denote the approximation ratio for (that is, corresponds to using an exact subroutine).

###### Theorem 1.

For levels, the top-down approach is a -approximation to MLST, the bottom-up approach is a -approximation, and taking the minimum of and is a -approximation.

###### Proof.

Let be the total cost produced by the top-down approach, and let denote the cost of edges on level but not level , produced by the top-down approach, so that . Define and analogously. Let denote the cost of a minimum Steiner tree over terminals with original edge weights, independently of other levels.

###### Lemma 1.

The following inequalities relate with :

 TOP1 ≤ρOPT1 (1) TOP2 ≤ρ(OPT1+OPT2) (2)
###### Proof.

(1) follows from the fact that is a -approximation for STP over , that is, . To show (2), note that is at most times the cost (denote ) of a minimum Steiner tree over in the instance obtained by setting for each . Thus, . Additionally, since spans by definition, we have , so as desired. ∎

Combining (1) and (2), we have , and hence the top-down approach provides a -approximation when .

Analogously to Lemma 1 in the two-level case, we have that for all . This holds as , where denotes the cost of the minimum Steiner tree over , with edges from having weight set to zero. Then .

Combining yields

 TOP =kTOP1+(k−1)TOP2+…+1TOPk ≤kρOPT1+(k−1)ρ(OPT1+OPT2)+…+1ρ(OPT1+OPT2+…+OPTk) =ρ((k+12)OPT1+(k2)OPT2+…+(22)OPTk) ≤k+12ρOPT.

In Fig. 2 we provide an example showing that our analysis is tight for .

###### Lemma 2.

The following inequality relates with for the two-level case:

 BOT1+BOT2≤ρ(OPT1+OPT2)
###### Proof.

This follows from the fact that , and that the tree with cost spans with cost at least . ∎

Hence, .

Analogously to Lemma 2, we have . Hence, we have

 BOT ≤k(BOT1+BOT2+…+BOTk) ≤kρ(OPT1+OPT2+…+OPTk) ≤kρOPT.

Again, the approximation ratio (for ) is asymptotically tight; see Figure 3.

We show that taking the better of the two solutions returned by the top-down and the bottom-up approach provides a -approximation to MLST for . To prove this, we use the fact that for any real numbers , and . Thus,

 min{TOP,BOT} ≤α(3ρOPT1+ρOPT2)+(1−α)(2ρOPT1+2ρOPT2) =(2+α)ρOPT1+(2−α)ρOPT2

Setting gives . Combining the graphs in Figures 2 and 3, we can show that, asymptotically, the ratio is tight.

To prove Theorem 1 for arbitrary , we again use the fact that for any . Applying the inequalities for and , we get:

 min{TOP,BOT}≤k∑i=1[((i+12)−k)α+k]ρOPTk−i+1

Since we are comparing to for some approximation ratio , we can compare coefficients and find the smallest such that the system of inequalities

 ((k+12)−k)ρα+kρ ≤kt ((k2)−k)ρα+kρ ≤(k−1)t ⋮ ((22)−k)ρα+kρ ≤t

has a solution . Adding the first inequality to times the last inequality gives , and it can be shown algebraically that simultaneously satisfies the above inequalities.

### 2.2 Composite Algorithm

We describe an approach that generalizes the above approaches in order to obtain a better approximation ratio for levels. The main idea behind this composite approach is the following: In the top-down approach, we choose a set of edges that spans , and then propagate this choice to levels by setting the cost of these edges to . On the other hand, in the bottom-up approach, we choose a set of edges that spans , which is propagated to levels . The idea is that for , we can choose a set of intermediate levels and propagate our choices between these levels in a top-down manner, and to the levels lying in between them in a bottom-up manner.

Formally, let with be a subset of levels sorted in increasing order. We first compute a Steiner tree for level , and then use it to construct trees similar to the bottom-up approach. Then, we set the weights of to zero (as in the top-down approach) and compute a Steiner tree for level in the reweighed graph. Again, we can use to construct the trees to . Repeating this procedure until spanning results in a solution to MLST. Note that the top-down and bottom-up heuristics are special cases of this setting, with and , respectively. Figure 4 provides an illustration of the propagations in the top-down, in the bottom-up, and in a general heuristic.

For any choice of , we have , with the convention . Using the lower bound , we can find an upper bound for the approximation ratio . Without loss of generality, assume Also, since all the equations and inequalities scale by , we let . Hence, we have:

 t=CMP(Q)OPT≤ρ∑mi=1(k−ℓi−1)MINℓi∑kℓ=1MINℓ=m∑i=1(k−ℓi−1)MINℓi.

As observed above, both the top-down and the bottom-up algorithms are special cases of the heuristics generated in the composite approach. For the top-down heuristic, The worst case happens when , for which we find For the bottom-up heuristic, The worst case happens when and , for which we find .

An important choice of is For , the worst case happens when and This results in . Indeed, this choice of  can be deduced from the -approximation algorithm (QoS) of Charikar et al. [6].

Note that, when , the only generated heuristics are the top-down and the bottom-up, and hence . This does not hold for larger values of , since the composite approach evaluates more heuristics and obtains a better ratio. Overall, has possible subsets, so there are different heuristics. The composite algorithm executes all of them and picks the solution with minimum cost. Thus:

 CMP=minQ⊆{1,…,k}CMP(Q),

where denotes the cost for a specific subset of .

More generally, for , the composite heuristic produces a -approximation, where is the largest real number that simultaneously satisfies the inequalities

 t≤m∑i=1(k−ℓi−1)MINℓi,

for all subsets and all choices of such that and . The system of inequalities can be expressed in matrix form as:

 Mks≥t⋅12k−1×1

where and is a matrix that can be constructed recursively as

 Mk=[k⋅12k−2×1Mk−102k−2×1Pk−1+Mk−1],Pk=[12k−2×102k−2×(k−1)02k−2×1Pk−1],

starting with . Therefore, for each value of , we can find the approximation ratio of the composite algorithm by solving a linear program (LP).

###### Corollary 1.

For any , the composite algorithm yields a -approximation to MLST, where the values of are listed in Figure 5.

Neglecting the factor  for now, the approximation ratio for is better than the ratio of guaranteed by Xue et al. [24] for the Euclidean case. (The additive constant in their ratio stems from using Arora’s PTAS as a subroutine for Euclidean STP, which corresponds to the multiplicative constant  for using an STP algorithm as a subroutine for MLST.) Recall that an improvement for was posed as an open problem by Karpinski et al. [13]. Also, for each of the cases our results in Corollary 1 improve the approximation ratios of and guaranteed by Charikar et al. [6] and by Karpinski et al. [13], respectively. On the other hand, our ratios increase with , while their results hold for every . The function in Figure 5 suggests that the approximation ratio of the composite algorithm will stay below for values of  much larger than . We found that the tangent line to the function at intersects  only at .

Since the number of heuristics in the composite algorithm grows exponentially with , it is computationally efficient only for small . Indeed, the composite heuristic for a level MLST problem requires STP computations. In the following, we show that we can achieve the same approximation guarantee through at most STP computations only.

###### Theorem 2.

For a given instance of the MLST problem, a specific choice of can be found through STP computations for which is guaranteed the theoretical approximation ratio of the composite heuristic.

###### Proof.

Given a graph with cost function , and terminal nodes , compute the Steiner trees on every level and find costs . Since this is not necessarily the optimal solution (assuming a worst-case scenario) to the LP for computing the approximation ratio , there exists at least one constraint for which . An instance of such constraint corresponds to the index with the minimum entry in the vector . Let be the index set corresponding to non-zero entries in the row of . We have . ∎

### 2.3 Hybrid Algorithm

We implemented the additional hybrid heuristic to overcome a potential limitation of all our other heuristics. Namely, in each of these algorithms we consider the levels in a certain order, and propagate the choices done at each level to those following in this order, but we never consider any level twice. In this way, if we make a bad choice at some point, we will never be able to recover it. The hybrid approach, instead, has the property that levels may be considered more than once. Also, the choices done at a certain level are still propagated to the following levels, but in a weaker way than in the other heuristics. In particular, instead of setting their weights to , we just set them to a fraction of their original cost.

More specifically, in order to compute , we first compute recursively. Then, we modify weights of so that, for each level , the weight of the edges corresponding to are scaled by . We then compute the Steiner tree on this reweighed graph, which will be part of our final solution. In order to compute the other trees of the solution, we restore the original weights for the edges in , except for those of , which are set to . Let be this reweighed graph. We then apply the same procedure to the instance to eventually obtain . Note that .

We observe that the hybrid approach for produces an approximation with the same ratio as and the composite, namely , as we show in Theorem 3, while for larger values of we have no guarantee. On the other hand, we will see in the following that this approach was quite stable in our tests, performing well on all the test suites, often better than all the other approaches.

We analyze the hybrid algorithm and prove that, for , it guarantees the same approximation ratio as and the composite algorithm.

Namely, we start by computing a Steiner tree that spans the set of terminals . Then, we construct a graph , where is defined as

 c′(e)↦{c(e)/2 if e∈EBOT,2c(e) otherwise.

Now we compute the Steiner tree that spans on . As a last step, we construct a graph , where

 c′′↦{0 if e∈E′TOP,1c(e) otherwise.

and compute the Steiner-tree spanning on .

###### Theorem 3.

The hybrid algorithm yields a -approximation to the 2-level MLST.

###### Proof.

The optimal solution for the 2-level MLST is lower-bounded as , where is the cost of the optimal Steiner-tree on level and respectively. Let denote the cost of the subtree of spanning all terminals of . We can split , where denotes the cost of edges in and denotes the cost of in comparison to the initial solution on . Since corresponds to a Steiner-tree spanning on the reweighed graph , we have , since spans and each edge supports half of its cost in the reweighed graph. Another tree that spans is and thereby holds. The combination of the two inequalities suggest:

 HYB1=HYB1,a+HYB1,b≤min{12BOT1,TOP1}+12HYB1,a

Using edges of , we can construct a tree that expands to a tree which covers . Therefore, . Here is subtracted, since is already part of .

Since , we can deduce from the previous inequalities, that

 2HYB1+HYB2 ≤BOT1+BOT2+2min{12BOT1,TOP1} ≤OPT+min{12BOT1,TOP1} ≤43OPT

As shown in Figure 6, we can construct a graph for which a approximation ratio is realized through the hybrid heuristic. Therefore, the ratio is tight.

## 3 Exact Algorithm

We first provide an integer linear programming (ILP) based on cuts which is very easy to understand.

### 3.1 ILP based on Cuts

This is the standard ILP formulation of the single-level Steiner tree problem. With , we refer to the set of edges that have exactly one endpoint in .

 Minimize∑e∈Ec(e)⋅xesubject to∑e∈δ(S)xe≥1∀S⊂V with ∅≠S∩T≠Txe∈{0,1}∀e∈E

This formulation generalizes to the -level multilevel Steiner problem by introducing for every edge variables that indicate if the corresponding edge is in for .

 Minimizek∑l=1∑e∈Ec(e)⋅xe,lsubject to∑e∈δ(S)xe,l≥1∀S⊂V with ∅≠S∩Tl≠Tl and 1≤l≤kxe,l+1≥xe,l∀e∈E and 1≤l

### 3.2 ILP based on Multi-commodity Flow

Recall the well-known flow formulation for  [18, 2]. It assumes that the input graph is directed, which we can achieve by simply replacing each undirected edge by two directed edges in opposite directions of the same cost. Let be a fixed terminal node, the source. An ILP formulation of STP using multi-commodity flow [23] is as follows:

 Minimize∑(i,j)∈Ecijyij (3) subject to∑vh∈N(vi)xpih−∑vj∈N(vi)xpji =⎧⎨⎩1i=s−1i∈T∖{s}0i∈V∖T for i∈V (4) xpij ≤yij (i,j)∈E,vp∈T (5) xpij ≥0 (i,j)∈E,vp∈T (6) yij ∈{0,1} (i,j)∈E. (7)

where is a binary variable indicating whether or not edge is included in the solution and denotes the neighbors of . The variable is the amount of commodity  (the amount of flow between vertices and ) on edge . Constraint 6 indicates that flow on an edge is allowed only if the edge is included in the solution. Constraint 4 dictates that one unit of commodity be routed between vertices and . In constraint 6 we can view as the flow capacity for commodity on edge . Constraints 47 indicate that a feasible solution must have a path of edges (i.e., ) between vertex and every vertex belonging to . Thus we represent the connectivity of the Steiner tree problem via an embedded multi-commodity network flow problem.

In MLST, if an edge is selected on level , it must be selected in all lower levels . We introduce binary variables , where if edge is selected on level , and additional flow variables for each level . We constrain that the graph on level is a subgraph of the graph on level as follows:

 yℓ+1uv≥yℓuvfor ℓ∈{1,2,…,k−1} and (u,v)∈E (8)

We also modify the objective function in the natural way:

 Minimize k∑ℓ=1∑uv∈Ec(u,v)⋅yℓuv (9)

### 3.3 ILP based on Single Flow

We now model the problem using single flow instead of multi-commodity flow which reduces the number of variables:

 Minimize ∑(u,v)∈Ec(u,v)⋅yuv (10) subject to ∑vw∈Exvw−∑uv∈Exuv =⎧⎨⎩|T|−1if v=s−1if v∈T∖{s}for v∈V0else (11) xuv ≤(|T|−1)⋅yuv (12) xuv ≥0 (13) yuv ∈{0,1} (14)

We can extend this formulation for MLST as we have done in the ILP based on multi-commodity flow. Note that while the ILP based on cuts is very easy to understand, it considers all subsets of and there is a constraint for every subset. Hence with that formulation, the number of constraints is exponential in the size of the graph. In the other two formulations, the number of constraints is polynomial to the size of the graph. We select this single-flow variant as it uses only one flow per level, while the multi-commodity variant requires multiple flows, one for each terminal. Since the number of constraints increases with the number of flows, that formulation is more expensive.

## 4 Experimental Results

Graph Data Synthesis.  The graph data we used in our experiment are synthesized from graph generative models. In particular, we used four random network generation models: Erdős–Renyi [9], random geometric [17], Watts–Strogatz [21], and Barabási–Albert [3]. These networks are very well studied in the literature [16]. A brief overview of each network generation model is as the following.

The Erdős–Renyi model, , assigns an edge to every possible pair among nodes with probability . It is well-known that an instance of with is almost surely connected for [9]. For our experiment vary from to and is equal to .

In the random geometric model, , points are uniformly randomly distributed in the unit square . In the output graph, each node corresponds to a single point, and nodes are connected to each other if their Euclidean distance is not larger than a threshold . For with , the synthesized graph is almost surely connected [17]. The value of in our experiment is .

The Watts–Strogatz model,