On Approximating Degree-Bounded Network Design Problems
Xiangyu Guo, Guy Kortsarz, Bundit Laekhanukit, Shi Li, Daniel Vaz,, Jiayi Xian

TL;DR
This paper introduces a quasi-polynomial time bicriteria approximation algorithm for the Degree-Bounded Directed Steiner Tree problem, achieving near-optimal cost guarantees while allowing controlled violations of degree constraints.
Contribution
It provides the first non-trivial approximation algorithm for the degree-bounded DST problem with explicit degree violation bounds.
Findings
Achieves an $O( ext{log} n ext{log} k)$ cost approximation.
Violates degree bounds by at most $O( ext{log}^2 n)$ factor.
Improves degree violation bounds for the special case of Degree-Bounded Group Steiner Tree on trees.
Abstract
Directed Steiner Tree (DST) is a central problem in combinatorial optimization and theoretical computer science: Given a directed graph with edge costs , a root and terminals , we need to output the minimum-cost arborescence in that contains an \textrightarrow path for every . Recently, Grandoni, Laekhanukit and Li, and independently Ghuge and Nagarajan, gave quasi-polynomial time -approximation algorithms for the problem, which are tight under popular complexity assumptions. In this paper, we consider the more general Degree-Bounded Directed Steiner Tree (DB-DST) problem, where we are additionally given a degree bound on each vertex , and we require that every vertex in the output tree has at most children. We give a quasi-polynomial time $(O(\log n…
Peer Reviews
No public reviews on file for this paper yet. If you reviewed it on a platform where reviews are public (OpenReview, ICLR, NeurIPS, ICML), you can paste yours below so the community can read it here.
Videos
No videos yet. Explain this paper in a talk, walkthrough, or lecture? Add one.
On Approximating Degree-Bounded Network Design Problems
Xiangyu Guo
Dept. of Comp. Sci. and Eng.
University at Buffalo, USA
Guy Kortsarz
Dept. of Comp. Sci.
Rutgers University Camden, USA
Bundit Laekhanukit
ITCS,
SUFE, China
Shi Li
Dept. of Comp. Sci. and Eng.
University at Buffalo, USA
Daniel Vaz
Operations Research Group,
TU Munich, Germany
Jiayi Xian
Dept. of Comp. Sci. and Eng.
University at Buffalo, USA
Abstract
Directed Steiner Tree (DST) is a central problem in combinatorial optimization and theoretical computer science: Given a directed graph with edge costs , a root and terminals , we need to output the minimum-cost arborescence in that contains an → path for every . Recently, Grandoni, Laekhanukit and Li, and independently Ghuge and Nagarajan, gave quasi-polynomial time -approximation algorithms for the problem, which are tight under popular complexity assumptions.
In this paper, we consider the more general Degree-Bounded Directed Steiner Tree (DB-DST) problem, where we are additionally given a degree bound on each vertex , and we require that every vertex in the output tree has at most children. We give a quasi-polynomial time -bicriteria approximation: The algorithm produces a solution with cost at most times the cost of the optimum solution that violates the degree constraints by at most a factor of . This is the first non-trivial result for the problem.
While our cost-guarantee is nearly optimal, the degree violation factor of is an -factor away from the approximation lower bound of from the set-cover hardness. The hardness result holds even on the special case of the Degree-Bounded Group Steiner Tree problem on trees (DB-GST-T). With the hope of closing the gap, we study the question of whether the degree violation factor can be made tight for this special case. We answer the question in the affirmative by giving an -bicriteria approximation algorithm for DB-GST-T.
1 Introduction
Network design is a central problem in combinatorial optimization and computer science. To capture more practical situations, the more general model of network design with degree-constraints was suggested in the early 90’s [21, 8] and has attracted researchers in both theory and practice for decades. One of the most famous examples is the Degree-Bounded Minimum Spanning Tree (DB-MST) problem, which models the problem of designing a multi-casting network in which each node only has enough power to broadcast to a bounded number of its neighbors. This problem has been studied in a sequence of works (see, e.g.,[15, 17, 11, 23]), leading to the breakthrough result of Goemans [11] followed by the work of Singh and Lau [23], which settled down the problem by giving an algorithm that outputs a solution with optimum cost, while violating the degree bound by an additive factor of +1 [23]. Since the works on DB-MST, many works have been dedicated to the study the generalizations of the problem: the Degree-Bounded Steiner Tree problem, in which the goal is to find a minimum-cost subgraph that connects all the terminals, while meeting the given degree bounds, was studied in [16, 20]. The Survivable Network Design problem, where each pair of nodes are required to have at least edge-disjoint - paths, has also been studied in literature; see, e.g., [19, 20].
Recently, degree-bounded network design problems have been studied in the online setting [4, 3, 5]. Besides the standard (also called point-to-point) network design problems, Dehghani et al. [4] also studied the Degree-Bounded Group Steiner Tree problem (DB-GST). They gave a negative result, which shows that it is not possible to approximate both cost and weight of the Online DB-GST problem simultaneously, even when the input graph is a star. More specifically, there exists an input demand sequence that forces any algorithm to pay a factor of either in the cost or in the degree violation. To date there was no non-trivial approximation algorithm for DB-GST, either in the online or offline setting, and even when all the edges have zero-cost. This was listed as an open problem by Hajiaghayi [13] at the 8th Flexible Network Design Workshop (FND 2016).
In this paper, we study a degree-bounded variant of the classic network design problem, the Degree-Bounded Directed Steiner Tree problem (DB-DST). Formally, in DB-DST, we are given an -vertex directed graph with costs on edges, a root vertex , a set of terminals , and degree bounds for each vertex . The goal is to find a minimum-cost rooted tree that contains a path from the root to every terminal , while respecting the degree bound, i.e., the out-degree of each vertex in is at most . Despite being a classic problem, there was no previous positive result on DB-DST as it is a generalization of DB-GST.
The barriers in obtaining any non-trivial approximation algorithm for DB-GST and DB-DST are similar. Most of the previous algorithms to these two problems either run on the metric closure of the input graph [9, 7, 22], require metric-tree embedding [9, 1, 6] or use height-reduction techniques [24, 2, 12, 10], all of which lose track of the degree of the solution subgraph.
We solve the open problem of Hajiaghayi [13], by presenting a bi-criteria -approximation algorithm for DB-DST that runs in quasi-polynomial-time (see Section 1.1 for the definition). Our technique expands upon the recent result of Grandoni, Laekhanukit and Li [12] for the Directed Steiner Tree problem. We observe that the algorithm in [12] can be easily extended to the problem with degree bounds. Nevertheless, to amend the degree-constrained problem into their framework, we are required to prove a concentration bound for the degrees, which is rather non-trivial. Notice that the -approximation factor on the cost of the tree is almost tight due to the hardness of in [14] for Directed Steiner Tree and the slightly improved hardness of in [12].
While our result for DB-DST is (almost) tight on the cost guarantee, the degree violation factor is an factor away from the approximation lower bound of from the set-cover hardness. To understand if the gap can be reduced, we study the special case of DB-DST obtained from the hardness construction in [14], namely the Degree-Bounded Group Steiner Tree problem on trees (DB-GST-T). In this problem, we are given an (undirected) tree with edge-costs, a root , subsets of vertices (called groups) and a degree bound for each vertex . The goal is to find a minimum-cost subtree that joins to at least one vertex from each group , for every , while respecting the degree bound, i.e., the number of children of each vertex in is at most . We present an -bicriteria approximation algorithm for DB-GST-T. So, the degree violation of our algorithm is tight and the cost-guarantee is almost tight. This improves upon the -bicriteria approximation algorithm due to Kortsarz and Nutov [18] who observe that the randomized rounding algorithm in [9] also gives a guarantee on degree-violation.
1.1 Our Results
Our first result is an -bicriteria approximation for DB-DST that runs in quasi-polynomial time: We say that a randomized algorithm is an -bicriteria-approximation algorithm if it outputs a tree containing an → path for every terminal such that the number of children of every vertex in is at most , and the expected cost of the tree is at most times the cost of the optimum tree that does not violate the degree constraints.
Theorem 1.1**.**
There is a randomized -bicriteria approximation algorithm for the degree-bounded directed Steiner tree problem in -time.
To the best of our knowledge, our result for DB-DST is the first non-trivial bicriteria approximation for the problem. As we mentioned, the -factor for the cost is almost tight due to the hardness results of [14] and [12] for DST. There is a hardness of for the degree violation factor from the set-cover problem, even if we ignore the cost of the output tree.
Remark
As in [12, 10], we could save a factor of in the approximation factor for the problem, with a slight increase in the running time. However, this complicates the algorithmic framework. To deliver the algorithmic idea in a cleaner way, we choose to present the results with approximation ratios.
Our second result is for the degree-bounded group Steiner tree problem on trees (DB-GST-T). We obtain an \big{(}O(\log n\log k),O(\log n)\big{)}-bicriteria approximation, which is (almost) tight on both factors:
Theorem 1.2**.**
There is a randomized \big{(}O(\log n\log k),O(\log n)\big{)}-bicriteria approximation for the degree-bounded group Steiner tree problem on trees.
1.2 Our Techniques
Our algorithm for degree-bounded directed Steiner tree takes ingredients from both [12] and [10]. As in these papers, we consider an optimum solution, and recursively partition it into balanced sub-trees; we then assign a “state” to each of these sub-trees. The tree structure of this recursive partition, as well as all of the states, form what we call a state tree. We solve the problem indirectly, by finding a good state tree, which we can transform back into a corresponding good solution. The state of a sub-tree contains a set of special vertices in the sub-tree that we call portals; these were used in [10] to obtain their improved approximation algorithm for DST. We construct a super-tree that contains all possible state trees as sub-trees and reduce the problem considered into that of finding a good sub-tree of small cost in . This can be done by formulating a linear program (LP) relaxation and rounding the LP solution using a recursive procedure. The construction of the super-tree and the LP rounding techniques are similar to those in [12]. To extend the algorithm to DB-DST, we need to store the degrees of all of the portals in the state.
This algorithmic framework outputs a so-called “multi-tree”: This is a tree where a vertex or an edge can appear multiple times. Repeating the procedure for times, we obtain a set of multi-trees. This process violates the degree requirements and thus we obtain bicriteria approximation results. The analysis of this process is non-trivial as we need to prove a concentration bound on the number of times a vertex appears in a multi-tree.
Our technique for DB-GST-T is in observing that the rounding algorithm for GST-T (no degree bounds) in [9] is indeed a generalization of random walk. As we slightly boost the branching probability by a constant factor, this (almost) does not affect the degree bound, but the probability of connecting the root vertex to each group is amplified dramatically. A drawback is that it also incurs a huge blow-up in the cost. To handle the blow-up, we stop amplifying the branching probability when the connecting probability is sufficiently large. The best (but inaccurate) way to illustrate our algorithm is by considering a random walk from the root vertex to a group . We change the random process by branching into two directions simultaneously in each step, and then stop the extra branching when it generates simultaneous random walks. Since we have simultaneous random walks, the cost incurred by the process is blown-up by a factor , but the degree-violation is blown-up by only a factor . At the same time, the probability of reaching the group goes up by a factor . Thus, if we need rounds to reach every group, then we now need only rounds. There is no difference in the cost for running the algorithm for rounds or rounds (with an extra factor in the cost), but it saves a factor in the degree-violation of .
2 Preliminaries for Degree-Bounded Directed Steiner Tree
2.1 Notations and Assumptions
In our algorithm and analysis for the DB-DST problem, a tree is always an out-arborescence. Given a tree , we use to denote its root. Given and a vertex in , we use to denote the set of children of , and to denote the set of descendants of (including itself) in the tree . A sub-tree of is a weakly-connected sub-graph of ; such a must be an out-arborescence. Sometimes, we shall use left and right children to refer to the two children of a vertex in a tree; in this case, the order of the two children is important and will be clearly specified. For an edge , we use to denote its tail. For a triple of three vertices, we use and to denote the second and third parameter of .
Our input digraph is . Let . We shall assume each terminal has only one incoming edge and no outgoing edges in . This can be assumed w.l.o.g using the following simple operation: For every terminal that does not satisfy the condition, we add a new vertex , an edge and replace with in . We increase by 1 and set .
One more assumption we can make is that each non-terminal has at most 2 outgoing edges in . To make sure that this holds, we focus on some non-terminal with outgoing edges. We replace the star centered at with its outgoing edges by a gadget which is a full binary-tree rooted at with leaves being the out-neighbors of . For every newly added vertex , we set . This way every vertex in will have at most outgoing edges. The cost of the edges in the gadget can be naturally defined. However, this operation changes the degree of vertices. To address this issue, we define a simple transformation function for every as follows: If is a vertex in the original graph, then is identically 1. Otherwise, is a non-root internal vertex of some gadget and we define to be the identity function. Then we can compute the original degree of a vertex in a tree of recursively as follows: if is a leaf, and otherwise. So, we require that for every in the output tree , the original degree of is at most .
2.2 Balanced Tree Partition
We shall use the following basic tool as the starting point of our algorithm design. Its proof is elementary and deferred to Appendix A.
Lemma 2.1**.**
*Let be an -vertex binary tree. Then there exists a vertex with . *
Given a tree as in the lemma, we can partition it into two trees and , where contains vertices in and contains vertices in . First assume . Since , we know that , thus implying , which is a leaf in . Consequently, we have and . Moreover, , which is strictly less than . Thus, and are sub-trees that form a balanced partition of (the edges of) . We call this procedure the balanced tree partitioning on .
When , there are 2 types of trees. If the root has two children, then we could not make both and to be smaller than . If the tree is a path of 2 edges, then we can choose to be the middle vertex and the procedure partitions the tree into two edges. Later, we shall apply the balanced tree partitioning procedure recursively. We stop the recursion when the tree is either an edge, or only contains the root and its 2 children. In other words, the tree has only 1 level of edges.
2.3 Multi-Tree
We define a multi-tree in as an intermediate structure. It is simply a tree over multi-sets of vertices and edges in :
Definition 2.2** (Multi-Tree).**
Given the input digraph , a multi-tree in is a tree where every vertex is associated with a label such that for every , we have .
We say that each vertex is a copy of the vertex and each edge is a copy of the edge . So, we say that is rooted at a copy of , if , and contains a copy of some if there exists some with . We extend the costs , the functions and the degree bounds automatically to their copies in a multi-tree. That means, for a vertex and an edge in a multi-tree, and . The cost of a multi-tree is naturally defined as . Given a multi-tree , the “original degree” of a vertex can be computed in the same way as before.
Definition 2.3** (Good Multi-Trees).**
Let be a multi-tree in . We say that is good if it is rooted at a copy of , has leaves being copies of terminals, and the original degree of any vertex in is at most .
We can then state the main theorem for DB-DST, which we prove in Sections 3 to 5.
Theorem 2.4** (Main Theorem for DB-DST).**
There is an -time randomized algorithm that outputs a good multi-tree such that
- (2.4a)
, where is the cost of the optimum solution for the instance. 2. (2.4b)
For every , we have . 3. (2.4c)
For some , it holds, for every , that
[TABLE]
We show that this implies Theorem 1.1.
Proof of Theorem 1.1.
We run the algorithm in Theorem 2.4 times to obtain good multi-trees , for some large enough . Our output will contain all edges that appear in the multi-trees. Notice that the output may not be a tree, but we can remove edges so that it becomes a tree. Applying union bound, all terminals appear in the union of the trees with probability at least , when is big enough. By Property (2.4c) in the theorem statement, we have for every ,
[TABLE]
The above inequality holds since the trees are produced independently.
Thus, if is big enough, by Markov’s inequality we have
[TABLE]
The event on the left side is exactly that the number of copies of in is at least .
Thus, with probability at least , every terminal appears in one of the trees and every vertex appears at most times in . Taking the union of all trees and reflecting the edges in original graph , we have a sub-graph of that contains a path from to every terminal . The total cost of edges in is at most . For every vertex , the out-degree of in will be at most . We can take an arbitrary Steiner tree in as the output of the algorithm. This gives us an -bicriteria approximation algorithm for the degree-bounded directed Steiner tree problem. The running time of the algorithm is . ∎
Organization
The remaining part of the paper is organized as follows. In Section 3, we define states and good state trees. In Section 4, we argue that the problem of finding a small cost valid tree can be reduced to that of finding a small cost state-tree. In Section 5, we present our linear programming rounding algorithm that finishes the proof of Theorem 2.4. Section 6 is dedicated to the proof of Theorem 1.2 for the degree-bounded group Steiner tree problem on trees (DB-GST-T).
3 States and State-Trees
Given the optimum tree (which is binary by our assumptions) for the DB-DST problem, we can apply the balanced tree partitioning recursively to obtain a decomposition tree: We start from and partition it into two trees and using the balanced-tree-partitioning procedure, and then recursively partition and until we obtain sub-trees with 1 level of edges: Such a tree contains either a single edge, or two edges from the root. Then the decomposition tree is a full binary tree where each node corresponds to a sub-tree of . Due to the balance condition, the height of the tree will be . Throughout the paper, we shall use to denote an upper bound on the height of this decomposition tree.
Thanks to its small depth, the decomposition tree becomes the object of interest. However, as each node in the tree corresponds to a sub-tree of the optimum solution , it contains too much information for the algorithm to handle. Instead, we shall only extract a small piece of information from each node that we call the state of the node. On one hand, a state contains much less information than a sub-tree does, so we can afford to enumerate all possible states for a node. On the other hand, the states of nodes in the decomposition tree still contain enough information for us to check whether the correspondent multi-tree is good. We call the binary tree of states a state tree; we require in a good state tree, the states of nodes satisfy some consistency constraints. Then we can establish a two-direction connection between good multi-trees and good state trees.
Given a valid tree in and a sub-tree of , we now start to make definitions related to the state of w.r.t . It is convenient to think that is the optimum tree and is a sub-tree of obtained from the recursive balanced-partitioning procedure, since this is how we use the definitions. However, the definitions are w.r.t general and ; from now on till the end of Section 3, we fix any valid tree and its sub-tree .
3.1 Portals
Other than , the state for w.r.t contains the set of portals of :
Definition 3.1**.**
A vertex in is a portal in , if is or a non-terminal leaf of .
In general, the set of portals of can be large, but if is obtained from the recursive balanced-tree-partitioning procedure for , then the number of portals can be shown to be at most . As we shall often use the root and set of portals together, we make the following definition:
Definition 3.2** (Root-Portals-Pair).**
* is called a root-portals-pair if .*
It is easy to see that the root-portal-pairs for an internal node of the decomposition tree and its two children satisfy some properties stated in the following definition:
Definition 3.3** (Allowable Child-Pair).**
Given three root-portals-pairs and , we say is an allowable child-pair of if and .
The following claim motivates the definition of allowable child pairs:
Claim 3.4**.**
Assume contains at least 2 levels of edges. Let and be the two sub-trees obtained by applying the balanced tree partitioning on . Let , and be the sets of portals in respectively. Then, is an allowable child-pair of .
Proof.
First, is not a portal of since it is a non-root internal vertex in of . Second, it is easy to see that and . So, and . ∎
3.2 Degree Vectors
The next piece of the information in a state is a degree vector:
Definition 3.5**.**
A degree vector for a set is a vector , where is an integer in for every .
Supposedly, will be the original degree of in the tree .
Definition 3.6** (Consistency of degree vectors).**
Given a root-portals-pair , an allowable child-pair of , three degree vectors and for and respectively, we say and are consistent with , if
- •
for every , we have ,
- •
for every , we have and
- •
.
So, the degree vectors are consistent if there is no contradictory information among them.
Definition 3.7** (Edge/Triple Agreeing with Degree Vector).**
Given a root-portals-pair with , a degree vector for , and an edge with , we say agrees with if , where denotes if is defined (i.e, if ) and otherwise.
Similarly, given a root-portals-pair with , a degree vector for , and two edges such that , we say the triple agrees with if .
Notice that in the above definition either or . In the former case, is defined; in the latter case is not defined but we know is identically 1. The same argument holds for . The definition corresponds to the case when is a base case of the recursive balanced tree partitioning, i.e., contains only 1 level of edges. If contains an edge , then the portal set of is . We shall have . Thus, if is restricted to the portal set, we have . Similarly, if contains 3 vertices with being the root, then we must have .
3.3 States and Good State-Trees
With degree vectors, we can define states and good state-trees:
Definition 3.8**.**
A state is a tuple where is a root-portals-pair and is a degree vector for .
The state of the tree w.r.t is the tuple with , being the set of portals in , and being the vector of original degrees of vertices in w.r.t the tree .
Definition 3.9** (Good State Trees).**
A good state tree* is a full binary tree of depth at most , where every node is associated with a state , and every leaf is associated with either an edge or a triple such that the following conditions hold.*
- (3.9a)
*. * 2. (3.9b)
For any leaf of , either or agrees with . 3. (3.9c)
For an internal node in , letting and be the left and right children of , then the pair is an allowable child-pair of (so, ), and and are consistent with .
We say that a terminal is involved in a good state tree if there exists a leaf of with , or .
Given a good state tree , and a leaf in , we define the cost as follows. If is defined, then we define ; otherwise, define . The cost of a state-tree is defined as .
4 Reduction to Finding Good State-Trees
4.1 From a Valid Tree to a Good State-Tree Involving All Terminals
In this section, we show that the decomposition tree of the optimum tree can be turned into a good state tree with cost that involves all terminals. As we alluded, the state tree is constructed by taking the state for each node in the decomposition tree for . Formally, it is obtained by calling (defined in Algorithm 1). In the algorithm is the vector of original degrees of all vertices in . The procedure is only for analysis purpose; it is not a part of our algorithm.
Lemma 4.1**.**
* is a good state tree involving all terminals and .*
Proof.
We first show that is a good state tree, by showing that it satisfies all the properties in Definition 3.9. Property (3.9a) trivially holds by the way we define the parameters for the root recursion of . Property (3.9b) holds by that each is restricted to . Property (3.9c) follows from the same facts and Claim 3.4. since every edge in counted exactly once in . ∎
4.2 From a Good State Tree to a Good Multi-Tree
Now we focus on the other direction of the reduction. Suppose we are given a good state tree , and our goal is to construct a good multi-tree with . Moreover, if a terminal is involved in , then contains a copy of .
The multi-tree is constructed by joining the edges associated with all leaf nodes in using a recursive procedure. For each node in we shall construct a multi-tree for , as well as a mapping from to vertices in . The multi-tree and the mapping satisfy the following properties:
- (P1)
For every , we have ; that is, is a copy of . 2. (P2)
.
In particular, the two properties imply that is a copy of .
The trees and mappings are constructed from the bottom to the top of the tree . Focus on a leaf node with . If is defined, then only contains a copy of the edge . maps to the copy of , and if (thus, ), to the copy of in . Otherwise is defined. Then contains a tree with two edges: a copy of and a copy of . can also be defined naturally.
Now consider the case that is an internal node and let and be its left and right children. Then, we have and by Property (3.9c). Then we identify with , and then the multi-tree is the new tree containing vertices in and . Notice that both and are copies of ; thus the obtained can be well-defined. The mapping is just the combination of and : For a vertex , let ; for a vertex , let ; since and we identified with , the mapping is well-defined. Also, it is easy to see that (P1) and (P2) holds for and .
Our final multi-tree for will be . It is straightforward to see that if is involved in , then contains a copy of . Notice that all the -vectors are consistent with each other, and for every leaf , or agrees with . Thus, aggregating all the vectors will recover the vector of original degrees of vertices in . So, the multi-tree is good since every in has . The cost of is .
5 Finding a Good State Tree using LP Rounding
5.1 Extended State Trees and Construction of
With the relationship between good multi-trees and good state trees established, we can now focus on the problem of finding a good state-tree of small cost involving many terminals. We shall construct a quasi-polynomial sized tree so that every good state-tree corresponds a sub-tree of satisfying some property. Roughly speaking, is the “super-set” of all potential good state-trees . However, since the consistency conditions are defined over three states for a parent and its two children, it is more convenient to insert a “virtual” node between every internal node and its two children. Also, it is convenient to break a leaf state node into two nodes, one containing the state information and the other containing or . Formally, for a good state-tree , we construct a correspondent tree as follows.
Let be a copy of . All nodes in are called state nodes. 2. 2.
For every internal state node in with left and right children and , we create a virtual node and replace the two edges and with 3 edges and ; is still the left child and is the right child. 3. 3.
For every leaf state node , we create a base node and let be the child of . Then we move the or information from the node to node : If is defined, then we let and undefine ; otherwise, let and undefine . 4. 4.
We add a super node and an edge from to the root of . will be the new root for .
We call this the extended state-tree for ; we say is good if its correspondent is good. Clearly, there is a 1-to-1 correspondence between good state trees and good extended state trees.
Our will be the “super-set” of all potential good extended state trees . Formally, we create a super node to be the root of . Then, for every , we call to obtain a tree and let its root be a child of .
The following claim is immediate from the construction of .
Claim 5.1**.**
A subtree of with is a good extended state tree if and only if the following happens:
- •
The super node in has exactly one child (which is a state node).
- •
Each state node in has exactly one child (which is an base node or a virtual node).
- •
For each virtual node in , both ’s children in are in .
On the other hand, every good extended tree of depth at most is a sub-tree of with root being .
Also, we say that a vertex is involved in if there is an base node in with or . The cost of , denoted as , is defined the sum of over all base nodes in . So, the problem now becomes finding a small-cost good extended state tree in that involves each terminal with large probability.
5.2 LP Formulation
We formulate an LP relaxation for our task. Let be the set of nodes in , and let and be the sets of state, virtual and base nodes in respectively. Notice that there is only one super node, which is the root . For every , let be the set of base nodes involving . Let be our target good extended state tree; this is the tree correspondent to the good state tree . Then, in our LP, we have a variable for every , that indicates whether is in the or not.
[TABLE]
[TABLE]
[TABLE]
The objective function of LP (1) is to minimize the total cost of all leaves in . (2) requires that for every state or super node in , exactly one child of is in . (3) requires that a virtual node in has both its children in . (5) says for every node in and every terminal , there is a most one descendant base node of that is in . In the whole tree , exactly one leaf node has or , for every (Constraint (6)); in the LP, all the variables are between [math] and (Constraint (4)).
Notice that (5) for and any and (6) for the same imply that . (2) and (3) imply that the values over the nodes of a root-to-leaf path in are non-increasing.
5.3 Rounding Algorithm
Given a valid solution to LP (1), our rounding algorithm will round it to obtain set , which induces a good state tree. The algorithm is very similar to that of [9] with the only one difference: For every state node or super-node that is added to , we add exactly one child of to , while the algorithm of [9] makes independent decisions for each child. The algorithm is formally described in Algorithm 3. In the main algorithm, we simply call .
It is straightforward to see that the tree induced by is a good extended state tree. The following claim also holds:
Claim 5.2**.**
Let and . Let be the random set returned by . Then we have .
Applying the above claim for and every , we have that the expected cost of the tree induced by is exactly .
The main theorem we need about the rounding algorithm is as follows:
Theorem 5.3**.**
Let be the random set returned by . Then, for any terminal we have
[TABLE]
Theorem 5.3 was proved [9] for the original rounding algorithm and was reproved in [22]. However, adapting the analysis to our slightly different rounding algorithm is straightforward and thus we omit the proof of the theorem here.
We now wrap up and finish the proof of the main theorem (Theorem 2.4) except for Property (2.4c), which will be proved in Section 5.4.
We solve LP(1) to obtain a solution . Notice that . Let . Then by Claim 5.1 and the rounding algorithm, the tree induced by is a good extended state tree. Let be the good state tree correspondent to , and let be the good multi-tree in constructed using the procedure in Section 4.2. The cost of the multi-tree is at most . By Theorem 5.3, for every , the probability that is involved is at least .
Let us consider the running time of the algorithmic framework, which is polynomial on the size of the tree . First notice that if is an allowable child pair of , then we have since . Thus, a state-node at the -th level in (the children of have level [math] and for simplicity we do not consider super and virtual nodes when counting levels) has . Thus, every state node in has .
Then we consider the degree of the tree , which is the maximum number of possible children of a state node with . First, there are at most different allowable child pairs of the pair : there are at most choices for and ways to split into and . Then, for a fixed allowable child pair we consider the number of pairs of degree vectors \big{(}\rho^{1},\rho^{2}\big{)} such that and are consistent with . This is determined by the value of , which has at most possibilities. So, the number of virtual children of a state node is at most since . The number of child base nodes of is at most . Since the height of the tree is at most , its size bounded by . So the running time of the LP rounding algorithm is . This finishes the proof of Theorems 2.4 except for Property (2.4c).
5.4 Concentration Bound on Number of Copies of a Vertex Appearing in
Finally, we prove Property (2.4c) in Theorem 2.4. To this end, we shall fix a vertex . For every vertex , let . By Constraint (5), we have . Let be the total number of nodes in that are selected by the rounding algorithm.
As is typical, we shall introduce a parameter and consider the expectation the random exponential variables (we use for the natural constant). We shall bound from bottom to top by induction. So, in this proof, it is more convenient to for us to use a different definition of levels: the level of a node in is the maximum number of edges in a path in starting from . So, the leaves have level [math] and for an internal node in , the level of is 1 plus the maximum of the level of over all children of . We define an for every integer as and . Notice that is an increasing sequence. Thus, we can induce the following lemma.
Lemma 5.4**.**
For any node be in of level at most , \operatorname*{\mathbb{E}}\Big{[}\mathbf{e}^{sm_{p}}\big{|}p\in\mathbf{V}\Big{]}\leq\alpha_{i}^{z_{p}/x_{p}}.
Proof.
We prove the lemma by induction on . If , then is a leaf, and thus, we have either or , depending on whether or not. If , then is always [math], and thus, \operatorname*{\mathbb{E}}\Big{[}\mathbf{e}^{sm_{p}}\big{|}p\in\mathbf{V}\Big{]}=1=\alpha_{0}^{z_{p}/x_{p}}. If , then is always (conditioned on ), and thus, \operatorname*{\mathbb{E}}\Big{[}\mathbf{e}^{sm_{p}}\big{|}p\in\mathbf{V}\Big{]}=\mathbf{e}^{s}=\alpha_{0}^{z_{p}/x_{p}}. So, the lemma holds if .
Now, let be any integer and we assume the lemma holds for . We shall prove that it also holds for . Focus on a node of level at most . Then all children of have level at most . If is a virtual node, then implies that both children of in . Since the two children are handled independently in the rounding algorithm, we have
[TABLE]
If is the super node or a state node, then we have . Conditioned on , the rounding procedure adds exactly one child of to . Then, we have
[TABLE]
Thus, we always have
[TABLE]
To see the second inequality in the last line, we notice the following three facts: (i) is a convex function of and when its value is [math], (ii) for every in the summation, and (iii) . So, the quantity inside has maximum value . The equality in the last line is by the definition of . ∎
Let be the level of the root. Now, we set . We prove inductively the following lemma:
Lemma 5.5**.**
For every , we have .
Proof.
By definition, and thus the statement holds for . Let and assume the statement holds for . Then, we have
[TABLE]
The first inequality used the induction hypothesis and the second one used that for every , we have . ∎
So, by Lemma 5.4 and 5.5, we have . This finishes the proof of Property (2.4c) in Theorem 2.4.
6 Bicriteria-Approximation Algorithm for Degree-Bounded Group Steiner Tree on Trees
In this section, we prove Theorem 1.2, which is repeated here. See 1.2
We first set up some notations for the theorem. Recall that is the input tree, denotes the set of vertices of , and denotes the root of . For simplicity, we assume the costs are on the vertices instead of edges: Every vertex has a cost . Notice that this does not change the problem. We have groups indexed by . For each group , we are given a set of leaves in . W.l.o.g, we assume all ’s are disjoint. Every vertex is given a degree bound . The goal of the problem is then to output the smallest cost subtree of that satisfies the degree constraints and contains the root and one vertex from each , . Since now we only have one tree , we use the following notations for children and descendants: For every vertex , let denote the set of children of in , and to denote the set of descendants of in (including itself).
Now we describe the LP relaxation we use for our problem. For every vertex , we use to indicate whether is chosen or not (in the correspondent integer program). LP (7) is a valid LP relaxation for the DB-GST-T problem:
[TABLE]
[TABLE]
[TABLE]
In the correspondent integer program, the objective we try to minimize is , i.e, the total cost of all verticies we choose. Constraint (8) says that if we choose a vertex then we must choose its parent . Constraint (9) requires for every group , exactly one vertex in is added to the tree. Constraint (10) holds since if is chosen, at most one vertex in is chosen for every group . Constraint (11) is the degree constraint. In the LP relaxation, we require each to take value in (Constraint (12)). Notice that (9) and (10) for the root imply that .
Modifying the LP solutions.
Solving LP (7), we can obtain the optimum LP solution . In our rounding algorithm, it would be convenient if every is a (non-positive) integer power of that is not too small. So, we shall modify the LP solution using the following operations, which may violate many of the LP constraints slightly. For every with , we change to [math]. This can only decrease the cost of the solution. It is easy to see that Constraints (8), (10) and (11) will not be violated. Constraint (9) may not hold any more, but we still have for every . We can remove all vertices with from the instance and thus assume for every . Next, we increase each to the smallest (non-positive) integer power of that is greater than or equal to . This will violate many constraints in the LP by a factor of . We list the properties that our new vector has:
- (P1)
For every , is an integer power of between and . 2. (P2)
The values along any root-to-leaf path in is non-increasing. 3. (P3)
for every group . 4. (P4)
for every and . 5. (P5)
for every . 6. (P6)
, where is the cost of the optimum integer solution.
6.1 The rounding algorithm
We now describe our rounding algorithm. We define two important global parameters: and . We say an edge with has “hop value” 1 if and [math] if . For every vertex , we define to be the sum of hop values over all edges in the path from the root to in . Thus, for every and , we have , and if and only if . By Properties (P1) and (P2), we have that for every .
Our rounding algorithm is applied on some scaled solution , which is defined as follows:
[TABLE]
As we mentioned in the introduction, this change will increase the probability of choosing conditioned on choosing by a factor of , for some with .
We prove one important property for , which is necessary for us to run the recursive rounding algorithm.
Claim 6.1**.**
For every and , we have .
Proof.
If then we have has hop value [math] and thus . In this case we have as well. Otherwise, we have and . So, and therefore . ∎
Notice that and every is an integer power of between and . Our recursive rounding algorithm is run over . In the procedure recursive-rounding, we add to our output tree and do the following: for every , with probability independent of all other choices, we call recursive-rounding. In the root recursion, we shall call recursive-rounding.
Our final algorithm will repeat the recursive procedure times independently, for a large enough . Let be the trees we obtained from the repetitions. Our final tree will be the union of the trees.
We first analyze the expected cost of . First focus on the tree . It is easy to see that the probability is chosen by is exactly . Therefore, the expected cost of is at most by Property (P6). Therefore, the expected cost of the tree is at most .
We then analyze the degree constraints on . Given that is selected by , the probability that we select a child of of is . By Property (P5), we have . Consider all the trees . Even if we condition on the event that appears in all the trees, the degree of is the summation of many independent random -variables. The expectation of the summation is at most . Using Chernoff bound, one can show that the probability that the degree of is more than is at most , for some large enough factor. Therefore, with probability at least , every node in has degree at most . Therefore, we proved that the degree violation factor of our algorithm is , as claimed in Theorem 1.2.
6.2 Analysis of connectivity probability
It remains to show that with high probability, the tree contains a vertex from every group. This is the goal of this section. Till the end of the section, we focus on the tree and a fixed group . For every vertex , we define to be the event that is chosen by . Our goal is to give a lower bound on , i.e, the probability that some vertex in is chosen by the tree .
Notice that when two adjacent nodes in have the same value, then the child is chosen whenever the parent is. Thus, we can w.l.o.g contract any sub-tree of nodes in with the same value into one single super-vertex, without changing the rounding algorithm. Notice that if two adjacent vertices have then we have and thus . So, we contract every maximal sub-tree of vertices in with the same value. After this operation, for every , is exactly the level of in the tree . So, for every and we have . A super-vertex is in if one of its vertices before contracting is in . If an internal super-vertex is in , we can remove all its descendants without changing the analysis in this section. So, again we have that only contains leaves.
For every vertex , we define
[TABLE]
Notice that by Property (P4).
In the following, we shall bound \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]} for every from bottom to top. This is done in two stages due to the threshold we used when we define variables. First we consider the case when and then we focus on the case when . The two stages are captured by Lemmas 6.2 and 6.3 respectively.
Lemma 6.2**.**
For a vertex with , we have \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]}\geq\frac{1}{2(L+1-\ell_{u})}\frac{z_{u}}{x_{u}}.
Similar lemmas have been proved multiple times in many previous results. Since our parameters are slightly different, we provide the complete proof here. There are two different approaches to prove the lemma, one based on bounding the conditional second moment of the random variable for the number of chosen vertices in , and the other based on the mathematical induction on , which is the one we use here.
Proof of Lemma 6.2.
Suppose is a leaf. Then if and otherwise. So, we have \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]}=\frac{z_{u}}{x_{u}} and the lemma clearly holds since we have .
Then, we prove the lemma by induction on . If then must be a leaf and thus the lemma holds. We assume the lemma holds for every with , for some . Then we prove the lemma for with . If is a leaf the lemma holds and thus we assume is not a leaf.
[TABLE]
The inequality in the first line used the induction hypothesis: is the probability that we choose in conditioned on that we choose , and is the lower bound on the probability that we choose some vertex in conditioned on that is chosen. The equality in the line used that and . The inequality in the second line used that for every real number . The first inequality in the third line used that for every . The second inequality in the line used Property (P4), which says . The last inequality used that since . ∎
The lemma implies that for every with , we have \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]}\geq\frac{1}{2L}\cdot\frac{z_{u}}{x_{u}}.
Now we analyze the probability for with . Recall that and thus we have . Let and for every , define . It is easy to see that for every , we have . Then, we have for every ,
[TABLE]
Therefore, we have
[TABLE]
The second inequality used that for every . The last equality used that and thus .
With the values defined, we prove the following lemma via mathematical induction:
Lemma 6.3**.**
For every vertex , we have \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]}\geq\alpha_{\ell}\frac{z_{u}}{x_{u}}.
Proof.
The lemma holds if as we mentioned. So, we assume and the lemma holds with replaced by . If is a leaf, then we have \Pr\Big{[}\bigvee_{o\in O_{t}\cap\Lambda^{*}_{u}}\mathbf{E}_{o}\big{|}\mathbf{E}_{u}\Big{]}=\frac{z_{u}}{x_{u}} and the lemma holds. So again we assume is not a leaf. Then,
[TABLE]
To see the equality in the first line, we notice that and for every . Many other inequalities used the same arguments as in Lemma 6.2. ∎
Applying the lemma for the root of , we have that \Pr\big{[}\bigvee_{o\in O_{t}}\mathbf{E}_{o}\big{]}\geq\alpha_{0}\cdot\frac{z_{r}}{x_{r}}\geq\alpha_{0}\cdot\frac{1}{2}=\Omega(1).
Now we consider all the trees together. The probability that is not chosen by any of the trees is at most , if our is big enough. Thus the probability that , the union of all trees , contains an -to- path for every , is at least .
Acknowledgement
X. Guo, S. Li and J. Xian are partially supported by NSF grants CCF-1566356, CCF- 1717134, CCF-1844890. B. Laekhanukit is partially supported by Science and Technology Innovation 2030 –“New Generation of Artificial Intelligence” Major Project No.(2018AAA0100903), NSFC grant 61932002, Program for Innovative Research Team of Shanghai University of Finance and Economics (IRTSHUFE) and the Fundamental Research Funds for the Central Universities and by the 1000-talent award by the Chinese Government. Daniel Vaz has been supported by the Alexander von Humboldt Foundation with funds from the German Federal Ministry of Education and Research (BMBF).
Appendix A Omitted Proofs
Proof of Lemma 2.1.
We assume ; otherwise, if , then we have , and satisfies the condition. Our goal is to find a vertex with . Start from in the tree, and thus, we have . Let be the child of with the biggest . So, . We then replace with . So has decreased but the condition is maintained. Thus, if we repeat the process, we will eventually find a with . ∎
The reference list from the paper itself. Each links out to its DOI / PubMed record.
- 1[1] Yair Bartal. Probabilistic approximations of metric spaces and its algorithmic applications. In 37th Annual Symposium on Foundations of Computer Science, FOCS ’96, Burlington, Vermont, USA, 14-16 October, 1996 , pages 184–193, 1996.
- 2[2] Moses Charikar, Chandra Chekuri, To-Yat Cheung, Zuo Dai, Ashish Goel, Sudipto Guha, and Ming Li. Approximation algorithms for directed steiner problems. J. Algorithms , 33(1):73–91, 1999.
- 3[3] Sina Dehghani, Soheil Ehsani, Mohammad Taghi Hajiaghayi, Vahid Liaghat, Harald Räcke, and Saeed Seddighin. Online weighted degree-bounded steiner networks via novel online mixed packing/covering. In 43rd International Colloquium on Automata, Languages, and Programming, ICALP 2016, July 11-15, 2016, Rome, Italy , pages 42:1–42:14, 2016.
- 4[4] Sina Dehghani, Soheil Ehsani, Mohammad Taghi Hajiaghayi, and Vahid Liaghat. Online degree-bounded steiner network design. In Proceedings of the Twenty-seventh Annual ACM-SIAM Symposium on Discrete Algorithms , SODA ’16, pages 164–175, Philadelphia, PA, USA, 2016. Society for Industrial and Applied Mathematics.
- 5[5] Sina Dehghani, Soheil Ehsani, Mohammad Taghi Hajiaghayi, Vahid Liaghat, and Saeed Seddighin. Greedy algorithms for online survivable network design. In 45th International Colloquium on Automata, Languages, and Programming, ICALP 2018, July 9-13, 2018, Prague, Czech Republic , pages 152:1–152:14, 2018.
- 6[6] Jittat Fakcharoenphol, Satish Rao, and Kunal Talwar. A tight bound on approximating arbitrary metrics by tree metrics. J. Comput. Syst. Sci. , 69(3):485–497, 2004.
- 7[7] Zachary Friggstad, Jochen Könemann, Young Kun-Ko, Anand Louis, Mohammad Shadravan, and Madhur Tulsiani. Linear programming hierarchies suffice for directed steiner tree. In Integer Programming and Combinatorial Optimization - 17th International Conference, IPCO 2014, Bonn, Germany, June 23-25, 2014. Proceedings , pages 285–296, 2014.
- 8[8] Martin Fürer and Balaji Raghavachari. Approximating the minimum-degree steiner tree to within one of optimal. J. Algorithms , 17(3):409–423, 1994.
