Survivable Network Design for Group Connectivity in Low-Treewidth Graphs

02/28/2018 ∙ by Parinya Chalermsook, et al. ∙ Max Planck Society Tel Aviv University IIIT Delhi 0

In the Group Steiner Tree problem (GST), we are given a (vertex or edge)-weighted graph G=(V,E) on n vertices, a root vertex r and a collection of groups {S_i}_i∈[h]: S_i⊆ V(G). The goal is to find a min-cost subgraph H that connects the root to every group. We consider a fault-tolerant variant of GST, which we call Restricted (Rooted) Group SNDP. In this setting, each group S_i has a demand k_i∈[k],k∈ N, and we wish to find a min-cost H⊆ G such that, for each group S_i, there is a vertex in S_i connected to the root via k_i (vertex or edge) disjoint paths. While GST admits O(^2 n h) approximation, its high connectivity variants are Label-Cover hard, and for the vertex-weighted version, the hardness holds even when k=2. Previously, positive results were known only for the edge-weighted version when k=2 [Gupta et al., SODA 2010; Khandekar et al., Theor. Comput. Sci., 2012] and for a relaxed variant where the disjoint paths may end at different vertices in a group [Chalermsook et al., SODA 2015]. Our main result is an O( n h) approximation for Restricted Group SNDP that runs in time n^f(k, w), where w is the treewidth of G. This nearly matches the lower bound when k and w are constant. The key to achieving this result is a non-trivial extension of the framework in [Chalermsook et al., SODA 2017], which embeds all feasible solutions to the problem into a dynamic program (DP) table. However, finding the optimal solution in the DP table remains intractable. We formulate a linear program relaxation for the DP and obtain an approximate solution via randomized rounding. This framework also allows us to systematically construct DP tables for high-connectivity problems. As a result, we present new exact algorithms for several variants of survivable network design problems in low-treewidth graphs.



There are no comments yet.


page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

Network design is an important subject in computer science and combinatorial optimization. The goal in network design is to build a network that meets some prescribed properties while minimizing the construction cost.

Survivable network design problems (SNDP) are a class of problems where we wish to design a network that is resilient against link or node failures.

These problems have been phrased as optimization problems on graphs, where we are given an -vertex (undirected or directed) graph with costs on edges or vertices together with a connectivity requirement . The goal is to find a minimum-cost subgraph , such that every pair of vertices are connected by edge-disjoint (resp., openly vertex-disjoint) paths. In other words, we wish to design a network in which every pair of vertices remains connected (unless ), even after removing edges (or vertices). The edge-connectivity version of SNDP (EC-SNDP) models the existence of link failures and the vertex-connectivity (VC-SNDP) models the existence of both link and node failures. These two problems were known to be NP-hard and have received a lot of attention in the past decades (see, e.g., [26, 16, 32, 34]).

While VC-SNDP and EC-SNDP address the questions that arise from designing telecommunication networks, another direction of research focuses on the questions that arise from media broadcasting as in cable television or streaming services. In this case, we may wish to connect the global server to a single local server in each community, who will forward the stream to all the clients in the area through their own local network. The goal here is slightly different from the usual SNDP, as it is not required to construct a network that spans every client; instead, we simply need to choose a local server (or representative), which will take care of connecting to other clients in the same group. This scenario motivates the Group Steiner Tree problem (GST) and its fault-tolerant variant, the Rooted Group SNDP.

In Rooted Group SNDP, we are given a graph with costs on edges or vertices, a root vertex , and a collection of subsets of vertices called groups, , together with connectivity demands , . The goal in this problem is to find a minimum cost subgraph such that has edge-disjoint (or openly vertex-disjoint) paths connecting the root vertex to some vertex , for all . In other words, we wish to choose one representative from each group and find a subgraph of such that each representative is -edge-(or vertex)-connected to the root.

When , the problem becomes the well-known Group Steiner Tree (GST) problem. Here, we are given a graph with edge or vertex costs, a root and a collection of subsets of vertices called groups, , and the goal is to find a minimum-cost subgraph that has a path to some vertex in each , for . The GST problem is known to admit an -approximation algorithm [22] and cannot be approximated to a factor of unless [25].

The Rooted Group SNDP generalizes GST to handle fault tolerance. The case where is studied in [27, 23], culminating in the -approximation algorithm for the problem. For , there is no known non-trivial approximation algorithm. It is known among the experts that this problem is at least as hard as the Label-Cover problem111The hardness for the case of directed graph was shown in [27], but it is not hard to show the same result for undirected graphs..

Chalermsook, Grandoni and Laekhanukit [13] studied a relaxed version of the problem in which we are not restricted to connect to a single vertex in each group and thus need only edge-disjoint paths connecting the root vertex to the whole group . Despite being a relaxed condition, the problem remains as hard as the Label-Cover problem, and they only managed to design a bicriteria approximation algorithm.

To date, there is no known bicriteria or even sub-exponential-time poly-logarithmic approximation for Rooted Group SNDP when . The following is an intriguing open question:

What are the settings (i.e., ranges of or graph classes) in which Rooted Group SNDP admits a poly-logarithmic approximation?

In this paper, we focus on developing algorithmic techniques to approach the above question. We design poly-logarithmic algorithms for a special class of graphs – graphs with bounded treewidth – in the hope that it will shed some light towards solving the problem on a more general class of graphs, for instance, planar graphs (this is the case for the Steiner tree problem, where a sub-exponential-time algorithm for planar graphs is derived via decomposition into low-tree width instances [33]).

Our main technical building block is a dynamic program (DP) that solves rooted versions of EC-SNDP and VC-SNDP in bounded-treewidth graphs. However, a straightforward DP computation is not applicable for Restricted Rooted Group SNDP, simply because the problem is NP-hard on trees (so it is unlikely to admit a polynomial-size DP-table). Hence, we “embed” the DP table into a tree and devise a polylogarithmic approximation algorithm using randomized rounding of a suitable LP-formulation. We remark that when the cost is polynomially bounded (e.g., in the Word RAM model with words of size ), polynomial-time algorithms for EC-SNDP and VC-SNDP follows from Courcelle’s Theorem [17, 6] (albeit, with much larger running time). However, employing the theorem as a black-box does not allow us to design approximation algorithms for Restricted Rooted Group SNDP.

To avoid confusion between the relaxed and restricted version of Rooted Group SNDP (usually having the same name in literature), we refer to our problem as Restricted Group SNDP. (For convenience, we also omit the word ”rooted”.)

1.1 Related Work

SNDP problems on restricted graph classes have also been studied extensively. When , the problems are relatively well understood. Efficient algorithms and PTAS have been developed for many graph classes: low-treewidth graphs [1, 18], metric-cost graphs [14], Euclidean graphs [9], planar graphs [8], and graphs of bounded genus [7]. However, when , the complexity of these problems remains wide open. Borradaile et al. [7, 10] showed an algorithm for on planar graphs, but under the assumption that one can buy multiple copies of edges (which they called relaxed connectivity setting). Without allowing multiplicity, very little is known when : Czumaj et al. [19] showed a PTAS for in unweighted planar graphs, and Berger et al. [3] showed an exact algorithm running in time for the uniform demand case (i.e., for all pairs ). Thus, without the relaxed assumption, with non-uniform demands or , the complexity of SNDP problems on bounded-treewidth graphs and planar graphs is not adequately understood.

The technique of formulating an LP from a DP table has been used in literature. It is known that any (discrete) DP can be formulated as an LP, which is integral [31]. (For Stochastic DP, please see, e.g., [30, 21, 11, 20].) However, the technique of producing a tree structure out of a DP table is quite rare. Prior to this paper the technique of rounding LP via a tree structure was used in [24] to approximate the Sparsest-Cut problem. The latter algorithm is very similar to us. However, while we embed a graph into a tree via a DP table, their algorithm works directly on the tree decomposition. We remark that our technique is based on the previous work in [12] with almost the same set of authors.

1.2 Hardness of Approximating Restricted Group SNDP

As mentioned, it is known among the experts that vertex-cost variant of the Restricted Group SNDP has a simple reduction for the Label-Cover problem and more generally, the -Constraint Satisfaction problem (-CSP). The original construction was given by Khandekar, Kortsarz and Nutov [27] for the Restricted Group SNDP on directed graphs. However, the same construction applies for the Vertex-Weighted Restricted Group SNDP. We are aware that this fact might not be clear for the readers. Thus, we provide the sketch of the proof in Appendix C.

We remark that the -CSP hardness implies that even for , Vertex-Weighted Restricted Group SNDP cannot be approximated to within a factor of , for any , unless , and the approximation hardness is conjectured to be polynomial on , say for some , under the Sliding Scale Conjecture [2]. So far, we do not know of any non-trivial approximation for this problem for .

The edge-cost variant has been studied in [27, 23], and a polylogarithmic approximation is known for the case [27]. For , there is no known non-trivial approximation algorithm. The relaxed variant where the disjoint paths from the root may end at different vertices in each group has also been studied in [27, 23]. Chalermsook, Grandoni and Laekhanukit proposed a bicriteria approximation algorithm for the Relaxed Restricted Group SNDP [13]; however, their technique is not applicable for the restricted version. Note that the hardness of the edge-cost variant of Relaxed Restricted Group SNDP is , for any [13]. It is not hard to construct the same hardness result for Restricted Group SNDP. We believe that Restricted Group SNDP is strictly harder than the relaxed variant.

1.3 Our Results & Techniques

Our main result is the following approximation result for Restricted Group SNDP.

Theorem 1.1.

There is an approximation for Restricted Group SNDP that runs in time for some function .

The proof of this theorem relies on the technique introduced in [12]. We give an overview of this technique and highlight how this paper departs from it.

In short, this technique “bridges” the ideas of dynamic program (DP) and randomized LP rounding in two steps222One may view our result as a “tree-embedding” type result. Please see [12] for more discussion along this line. Here we choose to present our result in the viewpoint of DP & LP.. Let us say that we would like to approximate optimization problem . In the first step, a “nice” DP table that captures the computation of the optimal solution is created, and there is a 1-to-1 correspondence between the DP solution and the solution to the problem. However, since the problem is NP-hard (in our case, even hard to approximate to within some poly-logarithmic factor), we could not follow the standard bottom-up computation of DP solutions. The idea of the second step is to instead write an LP relaxation that captures the computation of the optimal DP solution, and then use a randomized dependent rounding to get an approximate solution instead; the randomized rounding scheme is simply the well-known GKR rounding [22]. Roughly speaking, the size of the DP table is , while the LP relaxation has variables and constraints, so we could get an approximation in time .

The main technical hurdle that prevents us from using this technique to Restricted Group SNDP directly is that there was no systematic way to generate a “good” DP table for arbitrary connectivity demand . (The previous result was already complicated even for .) This is where we need to depart from the previous work. We devise a new concept that allows us to systematically create such a DP table for any connectivity demand . Our DP table has size for some function and , and it admits the same randomized rounding scheme in time , therefore yielding the main result.

As by-products, we obtain new algorithms for some well-studied variants of SNDP, whose running time depends on the treewidth of the input graph (in particular, ).

Subset connectivity problems:

Subset -Connectivity is a well-studied SNDP problem (Subset -EC and Subset -VC for edge and vertex connectivity, respectively). In this setting, all pairs of terminals have the same demands, i.e., for all . This is a natural generalization of Steiner tree that has received attention [14, 32, 29].

Theorem 1.2.

There are exact algorithms for Subset -EC and Subset -VC that run in time for some function . This result holds for vertex- or edge-costs.

Rooted SNDP:

Another setting that has been studied in the context of vertex connectivity requirements is the Rooted SNDP [15, 32]. In this problem, there is a designated terminal vertex , and all positive connectivity requirements are enforced only between and other terminals, i.e. only if or . For the edge connectivity setting, Rooted SNDP captures Subset -EC 333This is due to the transitivity of edge-connectivity. Specifically, any vertices that have edge-disjoint paths connecting to the root also have edge-disjoint paths between themselves.

Theorem 1.3.

There are exact algorithms for Rooted EC-SNDP and Rooted VC-SNDP that run in time for some function . This result holds for costs on vertices or edges.

Further technical overview:

Let us illustrate how our approach is used to generate the DP table, amenable for randomized rounding. The following discussion assumes a certain familiarity with the notion of treewidth and DP algorithms in low-treewidth graphs.

Given graph , let be a tree decomposition of having width , i.e. each bag corresponds to a subset . Let denote the subtree of rooted at . For each bag , let denote the subgraph induced on all bags belonging to the subtree of rooted at , i.e. . At a high level, DPs for minimization problems in low-treewidth graphs proceed as follows. For each “bag” , there is a profile for , and we define a DP cell for each possible such profile, which stores the minimum-cost of a solution (a subgraph of ) that is consistent with the profile . Then, a recursive rule is applied: Let be the left and right children of in respectively. The DP makes a choice to “buy” a subset of edges (that appear in bag ) and derives the cost by minimizing over all profiles that are “consistent” with :

where the sign represents the notion of consistency between the profiles. Different optimization problems have different profiles and consistency rules. Often, consistency rules that are designed for connectivity-1 problems (such as Steiner tree) are not easily generalizable to higher connectivity problems (such as SNDP).

In this paper, we devise a new consistency rule (abbreviated by ) for checking “reachability” (or connectivity 1) in a graph, which allows for easy generalization to handle high connectivity problems.

Roughly speaking, our consistency rule solves the Steiner tree problem (connectivity-1 problem). To solve a connectivity- problem, we have a DP cell for each . Then the consistency check is a “direct product” test for all coordinates, i.e.,

In this way, our new concept makes it a relatively simple task to generalize a DP for connectivity-1 problems to a DP for connectivity-k problems (and facilitate the proof of correctness). There is a slight change in the way DPs are designed for each problem, but they follow the same principle.


We develop our techniques over several sections, and along the way, show non-trivial applications for various SNDP problems. Section 2 provides some notation and important definitions. Section 3 presents the new viewpoint for designing DP and presents a simple showcase by deriving (known) results. Section 4 presents algorithms for EC-SNDP. Lastly, Section 5 presents an approximation algorithm for group connectivity problems.

2 Preliminaries

Tree decomposition:

Let be any graph. A tree decomposition of is a tree with a collection of bags (i.e., each node of is associated with a subset of nodes of ) that satisfies the following properties:

  • For any edge , there is a bag such that .

  • For each vertex , the collection of nodes whose bags contain induces a connected subgraph of . That is, is a subtree of .

The treewidth of , denoted , is the minimum integer for which there exists a tree decomposition such that ( is the width of ).

Fix a tree decomposition with the stated properties. For each node , denote by the subtree of rooted at . We also define as the subgraph induced by ; that is, .

For each , let denote the topmost bag for which . For each , we say that an edge appears in the bag if , and only if is the topmost bag in which this happens. We denote the edges inside the bag by . For a subset of bags, , we define .

We will use the following result, which shows that a tree decomposition of of width is computable in time .

Theorem 2.1 ([5]).

There is an algorithm that, given a graph , runs in time and finds the tree decomposition such that for all .

In order to simplify notation, we assume that is a binary tree. Furthermore, we require the height of to be in Section 5. The following lemma, based on the results of Bodlaender [4], summarizes the properties we assume.

Lemma 2.2 (in [12], based on [4]).

There is a tree decomposition with the following properties: (i) the height of is at most ; (ii) each bag satisfies ; (iii) every leaf bag has no edges ( for leaf ); (iv) every non-leaf has exactly children

Connection sets and operators:

Let . A connection set over is a subset of which will be used to list all pairs that are connected via a path, i.e., iff there is a path connecting to .

Figure 1: Connection sets, transitive closures and projections.
(dotted connections). . .

Let be a connection set over . The transitive closure operator, denoted by , is defined naturally such that contains all pairs for which there is a sequence and for all . Let . The projection operator” is defined such that . See Figure 1 for an illustration.

Given two connection sets of and of , the union is a connection set over .

3 New Key Concept: Global Local Checking for DP

This section introduces the key concept devised for handling all our problems systematically.

High-level intuition:

Our DP will try to maintain a pair of local and global information about connectivity in the graph. Roughly speaking, a local connection set for (more precisely, for ) gives information about connectivity of the solution inside the subgraph (the subgraph induced in subtree ), while the other connection for gives information about connectivity of the global solution (i.e., the solution for the whole graph ).

For instance, if we have a tentative solution , we would like to have the information about the reachability of inside each bag, i.e., , so we could check the reachability between and simply by looking at whether . However, a DP that is executing at bag may not have this global information, and this often leads to complicated rules to handle this situation.

We observe that global information can be passed along to all cells in the DP with simple local rules so that checking whether the connectivity requirements are satisfied can be done locally inside each DP cell. In the next section, we elaborate on this more formally.


One could imagine having a DP cell for all possible connection sets , which makes a decision on , the set of edges bought by the solution when executing the DP. The roles of and are to give information about local and global reachability, respectively. We are seeking a solution that is “consistent” with these profiles, where can be partitioned based on the tree as .

Given , we say that the pairs satisfy the local (resp., global) connectivity definition if, for every bag (having left and right children as and , respectively),


where the projection operator on is simplified as .

The main idea is that the local connectivity definition gives us “local” rules that enforce consistency of consecutive bags, and this would be suitable for being embedded into a DP. The global connectivity rules, however, are not easily encoded into DP, but it is easy to argue intuitively and formally about their properties. The following lemma (proof in Section 6) shows that the local and global connectivity definitions are, in fact, equivalent.

Lemma 3.1.

Let be a subset of edges and a pair of connectivity sets for every . Then, the pairs satisfy the local connectivity definition iff they satisfy the global connectivity definition.

The notions of local and global connectivity, as well as the equivalence between them can be generalized both for the edge-connectivity version with vertex-costs as well as vertex-connectivity with vertex-costs. We defer the details of this generalization to Appendix B.

A warmup application: steiner trees.

We now show an approach that allows us to solve the Steiner Tree problem exactly in time, given a tree decomposition of width . We remark that the best known algorithm due to Cygan et al. [18] runs in time . In this problem, we are given graph with edge-costs and terminals , and the goal is to find a min-cost subset that connects all the terminals. For simplicity, we denote by “root” , and the goal is to connect the root to all other terminals in .

Our DP table has a cell for every bag and every pair of connection sets for . We initialize the DP table by setting for all the leaf bags, and setting certain cells as invalid (by setting :

  • For every leaf bag and every pair , we set if and otherwise.

  • We mark the cells as invalid if .

  • Let be one of the terminals, and a bag. We mark a cell as invalid if but .

For all other cells, we compute the bags from their children. Let be a bag with left-child and right-child . Let be pairs of connection sets for , respectively, and . We say that is consistent with via (abbreviated by the notation ) if

Now, for any choice of valid DP cells and edge subsets for every (notice that a DP solution uses precisely one cell per bag ), we apply Lemma 3.1 to conclude that since the local connectivity definition is satisfied for pairs, so does the global connectivity definition. Since, for every valid DP cell such that contains a terminal , , we conclude that every terminal is connected to the root in the solution .

Conversely, given a solution , we can define , and a pair for every , using the global connectivity definition. Lemma 3.1 implies that the pairs satisfy the local connectivity definition, and therefore define valid DP cells (notice that for every terminal , connects to the root, so for every such that ). We thus establish that for every valid DP solution there is a corresponding feasible solution , and vice-versa.


Figure 2: Example of different partitions of edges into paths from demands , . On the left (resp., right), two paths from to (resp., )

4 Extension to High Connectivity

This section shows how to apply our framework to problems with high connectivity requirements. We focus on edge-connectivity and leave the case of vertex-connectivity to Appendix B.

When solving a problem in a high connectivity setting, there may be a requirement of disjoint paths. In particular, for each demand pair , there must be disjoint paths in the solution. So we could start naturally with a profile of the form:

for each bag , and enforce the local consistency conditions for each coordinate.

However, this idea does not work as a different demand pair, say , might use a path that belongs to different subgraphs as defined above. In other words, the disjoint paths for the demand pair might require a different partitioning of the solution set . Figure 2 illustrates a case in which different demand pairs use different partitions. Therefore, we need to enumerate all possible ways for the demands to “locally” partition the graph and use them to support all disjoint paths for each one of them. This requires a more careful local consistency check between the DP cells.

We consider the Rooted EC-SNDP problem with edge-costs as an example to explain how to apply our framework in high-connectivity. For convenience, we add to every bag. To avoid confusion, the root of the tree will be referred explicitly as .

The organization of this section is as follows. In Section 4.1, we explain the setup of the cells of the DP table and a high-level intuition about how the DP works. In Section 4.2 we describe the algorithm, in particular, how to compute the values of the DP table. We leave the discussion of its correctness and running time to Section 7.2.

4.1 Profiles

As in any standard dynamic programming approach based on tree decomposition, we have a profile for each bag , which tries to solve the subproblem restricted to in some way.

Let be a bag. A connection profile for is a k-tuple such that . Let be the set of all connection profiles for . A profile of node is a collection of pairs of connection profiles , i.e., . A partial solution is said to be consistent with profile for if, for all ,

  • For each and for , there are paths connecting the respective vertices in such that and are edge-disjoint.

  • There is a global solution such that, for each and for , there are paths connecting the respective vertices in such that and are edge-disjoint.

In other words, a solution consistent with a profile must “implement” all connectivity requirements by and must be extensible to satisfy .

Passing down both local and global requirements in the DP table leads to a clean and simple DP algorithm. Our DP table has a cell for each bag and each profile for . This cell tentatively stores the optimal cost of a solution consistent with profile .

4.2 The DP

Valid cells:

Some table entries do not correspond to valid solutions of the problem, so we mark them as invalid and remove them from consideration (another way to think about this is that we initialize for all invalid cells), i.e., the following cells are invalid:

  • Any leaf that has non-empty connectivity requirements is invalid. That is, if ; otherwise, .

  • Any cell that cannot be extended into a feasible solution is invalid. If there is no pair such that for all , then there are fewer than edge-disjoint paths between and , and therefore the cell is invalid, so .

  • The bag together with profile is an invalid cell if there is a pair such that for some . In this case, we set .

Lemma 4.1.

For every , there are at most many valid cells .

DP computation:

For all other cells, we compute their values from the values of their children. Let be a bag with left-child and right-child . Let be their profiles respectively, and . We say that is consistent with via (abbreviated by ) if the following conditions are satisfied. For each pair , there are and , together with a partition of into such that, for every ,

Similarly, for any (resp., ) there are (resp., ) plus and some partition of , satisfying similar conditions as above.

Then the value of can be defined recursively among valid cells:

The final solution can be computed as . The correctness of this DP is deferred to Section 7.1.

5 Algorithms for Restricted Group SNDP

We now have sufficient technical tools to prove Theorem 1.1. In the first step, we turn the DP table into a tree instance of a variant of GST and, in the second step, apply randomized rounding to obtain a polylogarithmic approximation to the problem.

Tree Instance:

We start by showing how to transform the DP table into a tree , where we can solve a variant of the group Steiner tree problem. The following theorem formalizes this transformation, and we dedicate the rest of this section to proving the theorem. For convenience, we add a dummy bag with as the parent of the root bag.

Theorem 5.1.

Given a graph rooted at with treewidth and groups , there is a tree with groups and a set of accepted solutions such that: (i) the size of is ; (ii) for every , there is (and vice-versa) such that and, for every , -connects to iff connects to .

For each cell of the DP table introduced in Section 4.2, we create a node in . Namely, we create a vertex for every bag and . The root of the tree is (this is the only connection profile for ). For a bag with children , , we add connecting nodes connected to the nodes , , , for every , if . If there is only one child, the connecting node has degree , and we consider that for the purpose of describing the algorithm. An edge from to is labeled with the set of edges and is assigned cost . All other edges in the instance have cost .

Notice that, at this point, is not a tree, but we can turn it into one by making copies of the nodes as required. Specifically, we process the tree in a bottom-up fashion: for each node , we make the same number of copies of and its descendants as there are incoming edges of such that each edge is incident to a different copy. In this manner, all the copies of are now the roots of subtrees, which are disjoint.

For convenience, we denote by (resp., ) any copy of the original node; when we need to distinguish copies, we denote by the set of all copies of a node .

The final step in our construction is to prune the tree by removing nodes that cannot be reached or that represent choices that cannot be part of a feasible solution. To do that, it is sufficient to apply the following rules to exhaustion: (i) remove if it is not connected to the root; (ii) remove a connecting node if one of its children was removed; (iii) remove if it is a leaf node but (i.e.  for some ).

We can now restate the goal of the problem in terms of : we want to find nodes and edge sets for every bag , such that for all non-leaf bags with children , . Further, for every group , there must be a vertex and a partition of into sets, such that each contains a path from to .

The set of nodes with the respective connecting nodes (for all non-leaf bags ) induces a tree in . We say that such a tree is valid if every node has exactly one child in the graph (or none if is a leaf), and every connecting node in has full-degree, i.e., all its neighbors are in the solution as well.

For every group , we define as follows: for every and every , every element of is in if there is such that for all .

The size of the instance follows by considering its height and maximum degree: the maximum degree of is by Lemma 4.1, and there is a tree decomposition of height by Lemma 2.2, which implies that . We conclude that .

The correctness of the reduction follows from the correctness of the DP for Rooted EC-SNDP, and its proof is left to Section 7.1.


We now show how to obtain a valid tree , given . Let be the min-cost valid tree in that connects all the groups . Chalermsook et al. [12] showed that it is possible to find a valid tree with expected cost

, but whose probability of covering a group is just


Using this result, we can obtain valid trees , …, , where . We can then obtain solutions that -connect the same groups and have the same cost as , for all , and finally output the solution . Since the expected cost of each is , the expected cost of is .

By sampling independent valid trees, for large enough , we ensure that all the groups are covered with high probability (by union bound). We conclude that the algorithm outputs a randomized -approximation to the problem, with high probability.

6 Details of the Global Local Checking for DP

In this section, we will prove a generalized version of Lemma 3.1, that works for edge-connectivity and vertex-connectivity, both with edge and vertex costs. In vertex-connectivity problems, we are interested in finding internally disjoint paths. In order to handle this setting, we introduce a modified version of transitive closure.

For a set of vertices and a set of edges , we denote by the set of all pairs such that there is a --path in the graph , that is, a path whose internal vertices are in , and whose edges are in . Formally,

We then keep track, for every bag, of which vertices are allowed to be used in the solution, that is, we use triples , instead of the previously used pairs .

Let for every , , for every , , and a triple for every . For the purposes of this section, we introduce the following definitions for local and global connectivity.

We say that the triples satisfy the local (resp. global) connectivity definition if, for every bag ,


We then prove the following lemma, proving that the given local and global connectivity definitions are equivalent.

Lemma 6.1.

Let be a subset of vertices, a subset of edges and a triple of profiles for every .

Then, the triples satisfy the local connectivity definition iff they satisfy the global connectivity definition.

Before proving the lemma, we show how Lemma 3.1 follows. We will prove that, if we fix and , the definitions of Lemmas 3.1 and 6.1 are equivalent.

For this, it is sufficient to see that , and that the common vertices in , , and are all in , thus

Similarly, since and only intersect inside ,

We conclude that when , and , the proof follows.

The following technical lemma will be useful when proving Lemma 6.1.

Lemma 6.2 (Path Lemma).

Let be any graph and be a tree decomposition of . Let be a bag and be a path of length at least whose endpoints are the only vertices of in , that is, .

Then there is a connected (subtree) component in such that, for any edge , has a bag that contains , i.e., every edge for some bag .


We provide a simple proof by contradiction. Assume that there are two consecutive edges, that are in different connected components of (otherwise, all edges must be in the same component). Since the set of bags containing must be connected in but is not connected in , , we reach a contradiction. ∎

Proof of Lemma 6.1.

We remark that the function shares some properties with the usual definition of transitive closure, which are used throughout the proof:

Observation 6.3.

The function satisfies the following properties:

  • if ,

Equivalence for