Structural Parameterization of Steiner Tree Packing
Abstract
Steiner Tree Packing is a notoriously hard problem in classical complexity theory, which is of practical relevance to VLSI circuit design. Previous research has approached this problem by providing heuristic or approximate algorithms. In this paper, we show the first algorithms for parameterized by structural parameters of the input graph. In particular, we show that is fixed-parameter tractable by the tree-cut width as well as the fracture number of the input graph.
To achieve our results, we generalize techniques from Edge-Disjoint Paths () to Generalized Steiner Tree Packing (), which generalizes both and . First, we derive the notion of the augmented graph for analogous to . We then show that is by
-
the tree-cut width of the augmented graph,
-
the fracture number of the augmented graph,
-
the slim tree-cut width of the input graph.
The latter two results were previously known for ; our results generalize these to and improve the running time for the parameter fracture number. On the other hand, it was open whether is parameterized by the tree-cut width of the augmented graph, despite extensive research on the structural complexity of the problem. We settle this question affirmatively.
Keywords and phrases:
Steiner tree packing, structural parameters, fixed-parameter tractabilityFunding:
Niko Hastrich: This work is part of the project TIPEA that has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement No 850979).Copyright and License:
2012 ACM Subject Classification:
Theory of computation Fixed parameter tractability ; Theory of computation Graph algorithms analysisFunding:
This work was conducted in part at Hasso Plattner Institute, University of Potsdam.Editors:
Meena Mahajan, Florin Manea, Annabelle McIver, and Nguyễn Kim ThắngSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
In Steiner tree packing (), we are given a triple , where is a graph, is the terminal set, and is the demand. The goal is to decide whether there are edge-disjoint trees in which all contain the vertices . It is easy to see that the problem is polynomial-time solvable if or . However, even for or , is already [19, 1]. Despite this obstacle, – and the related problems and , which we introduce shortly – has extensive applications. The problem has been closely studied in the context of VLSI circuit design [22, 5, 7, 23, 25, 17], designing computer networks for multicasting [24, 6, 15], and video-conferencing [28].
From a more theoretical perspective, Steiner Tree Packing has seen a long line of research focusing on the optimal gap between the edge connectivity of the terminal set and the size of the tree packing. On the one hand, if there are edge-disjoint subgraphs connecting , is clearly -edge-connected. On the other, Kriesell [21] conjectured that if is -edge-connected, then contains edge-disjoint trees connecting . While the conjecture remains open, we know that –edge-connectivity is sufficient [8]. These results are constructive, providing algorithms that approximate the size of a maximum Steiner tree packing within a constant factor in polynomial time. However, even by proving the original conjecture of Kriesell one could only obtain a -approximate algorithm for .
The situation with exact polynomial-time algorithms for is considerably more restrictive. As discussed above, in terms of the size of the terminal set and the demand , we can only expect polynomial time when both are bounded. In fact, it follows from the celebrated result of Robertson and Seymour [26], that is fixed-parameter tractable by . However, this result is non-constructive and the running time as a function of is enormously fast-growing; in particular, this result has very little practical relevance.
Therefore, it is natural to turn to structural properties of the input graph, in order to identify cases where the problem can be solved efficiently. Specifically, we are interested in algorithms for under the respective parameter. Prior to this work, no such algorithms were known. In fact, for treewidth this is highly unlikely. has Integer 2-Commodity Flow as a special case [1], and this problem has recently been shown to be parameterized by treewidth [2]. Thus, is also parameterized by treewidth, even on instances where the terminal set contains just three vertices.
To identify regimes where algorithms for are feasible, we first turn our attention to the closely related Edge-Disjoint Paths () problem. An instance is a tuple , where is a graph and is a set of terminal pairs in . The task is to decide whether for each there is an -path in such that all are pairwise edge-disjoint. This problem is when parameterized by [26]. However, it is notoriously hard with respect to common structural parameters. In fact, is even on complete bipartite graphs where one side contains 3 vertices [10]. These graphs have a vertex cover of size 3, which rules out algorithms for parameterized by any of the following classical structural parameters unless : treewidth, fracture number111Fracture number is equivalent to another parameter called vertex integrity., size of the smallest feedback vertex set, size of the smallest vertex cover.
Still, there are several algorithms known for . They fall in two categories. The first category are algorithms with respect to structural parameters that are based on edge-cuts, like slim tree-cut width, rather than vertex-cuts, like treewidth [13, 12, 3, 14]. The second category of algorithms are based on structural parameters, considered not with respect to the host graph , but rather to the augmented graph , where an edge is inserted between every terminal pair [14]. Intuitively, this captures the relations between the terminal pairs directly in the graph structure. This allows for positive results. For example, is for graphs of fracture number 3, but fixed-parameter tractable by fracture number of the augmented graph [14]. However, these results for carry little direct implication for , as there is no simple reduction known between instances of one problem to the other.
In order to provide a unified perspective on both and , we consider the following Generalized Steiner Tree Packing () problem, which can be seen as a version of with multiple terminal sets. Formally, in we are given a triple , where is the underlying graph, is the set of terminal sets, and gives the demand for each terminal set. Our task is to decide whether there is a set of pairwise edge-disjoint, connected subgraphs of and an assignment function such that every solution subgraph is assigned to a terminal set , which is contained in (i.e., ). Additionally, for every terminal set , the assignment function needs to assign many solution subgraphs to . The problem is not only a natural generalization of both and , but was also studied directly, e.g., in the area of VLSI design [17, 22, 7]. Note that in the literature both and are often referred to as “Steiner tree packing”; throughout this work, we stick to the formal definitions of and as above, in order to avoid ambiguity.
Our contribution.
In this paper, we generalize all known algorithms for parameterized by structural parameters to , which greatly extends the applicability of the underlying techniques. In particular, this allows us to apply them to . Moreover, in doing so, we discover new algorithms for . We positively settle the open question, whether is with respect to the tree-cut width of the augmented graph in the affirmative. Finally, we also improve the running time of several known algorithms for . See an overview of our results in comparison to previously known results in Table 1.
| Host | Aug. | Host | Aug. | Host | Aug. | |
| [1, 2] | [10] | [14] | [10] | [14] | ||
| Theorem 30 | Theorem 30 | Theorem 30 | ||||
| Theorem 13 | [10] | Theorem 13 | [10] | Theorem 13 | ||
| Corollary 31 | [13] | Corollary 28 | [13] | Corollary 28 | ||
| Corollary 21 | [12, 3] | Corollary 21 | ||||
Overview and structure.
This paper is structured as follows. We start in Section 2 by introducing relevant definitions and notation. In Section 3, we extend the notion of augmentation from to . To the best of our knowledge, such a generalization was not studied before. We argue that among two natural approaches, one is strictly more general, and we settle on it for the remainder of this paper.
Building on this definition, we show in Section 4 that is parameterized by the fracture number of the augmented graph. This result directly applies to parameterized by the fracture number of the host graph. This is in stark contrast to the fact, that , and therefore , is parameterized by the fracture number of the host graph [10]. The running time we obtain is doubly exponential in the parameter. This improves upon the triply exponential running time obtained by Ganian et al. [14] for parameterized by the fracture number of the augmented graph.
We then focus on results using tree-cut decompositions in Section 5. First, we define an additional property for tree-cut decompositions, which we call being simple. We use this property to streamline our algorithms on tree-cut decompositions, which we believe might be of independent interest. Then, we show how to decide an instance of given a simple tree-cut decomposition. For tree-cut decompositions, we are interested in two measures of the decomposition, its width and slim width, where the former is bounded by a function of the latter. We then show how the latter result can be applied to obtain an algorithm parameterized by the slim tree-cut width of the host graph and the tree-cut width of the augmented graph. This directly implies that is by the tree-cut width of the augmented graph, which was not known before.
Augmentation of a single terminal set can increase the tree-cut width arbitrarily. So, the previous result does not directly translate to an algorithm for . In Section 6, we examine this further. We show that we can avoid this hurdle, and provide an algorithm for parameterized by tree-cut width of the host graph. This result combines most of the other results obtained in this paper. To achieve this, we use a win-win strategy by the size of the terminal set. If the size of the terminal set is small, then augmentation does not increase the tree-cut width much, and we apply the result obtained in Section 5. Otherwise, we show that we can assume the demand to be small. We then develop an algorithm for parameterized by the sum of treewidth and demand. As treewidth dominates tree-cut width, this algorithm can be used to solve the remaining case. Additionally, this algorithm directly applies to parameterized by the sum of treewidth and the number of terminal pairs improving the previously known running time [29].
Omitted proofs.
Due to space constraints, proofs are omitted from this extended abstract. They were provided to the reviewers and can be found in the full version of this paper [18].
2 Preliminaries
We denote the natural numbers by and the positive natural numbers by . Let , let and . For any set , we denote with its power-set. Let be a graph. Unless explicitly stated otherwise, we only consider simple graphs. Let , we refer to the edges with exactly one endpoint in by . Let , contracting merges and into a single vertex, while keeping vertices adjacent to or adjacent to the combined vertex. Similarly, contracting a vertex set merges all the vertices in into a single vertex, while keeping vertices adjacent to at least one vertex of adjacent to the new vertex. Let , suppressing is the operation of inserting edges between all neighbors of and removing . The set of maximally connected subgraphs of is denoted with . Let be a hypergraph. is minimally connected if we can remove no hyperedge while preserving connectivity.
Now, we give the definitions of the structural parameters that we consider. For any parameter that is based on a decomposition, which contains a graph on vertex-sets of , we refer to the vertices of as nodes or bags and to its edges by links.
Fracture Number.
Let . We call a fracture modulator if every component in contains at most vertices. The size of the smallest fracture modulator is called the fracture number of . Dvorák et al. [9] claim that for any graph , one can find a fracture modulator of minimal size in time . We note that their proof suffers from a minor inaccuracy, and present a corrected version that runs in time , see Appendix A of the full version for details. Fracture number is always at most a factor of two away from another parameter called vertex integrity.
Tree-Cut Width.
The parameter tree-cut width was introduced by Wollan [27].
Definition 1.
A tree-cut decomposition of a graph is a tuple , where is a rooted tree and a near-partition of .
Here, subsets in a near-partition may be empty, as opposed to a partition. For a node , let be the sub-tree rooted at and we set to be the vertices contained in the bags of . Let be the graph induced by all edges crossing the link between and its parent, which we refer to as the boundary at . The adhesion of is defined as .
The torso of a tree-cut decomposition at node , denoted as , is the graph obtained from as follows. Consider the connected components of and for each , define . The torso at is obtained from by contracting for all the sets into a single vertex . Note that this may create parallel edges. Consider the unique graph , obtained from , by repeatedly suppressing vertices not in of degree at most and removing loops. is called the 3-center of with respect to .
Definition 2.
The width of the tree-cut decomposition is
The tree-cut width of is the smallest width of a tree-cut decomposition. We call empty if and we denote with the set of children of in . We call thin if and bold otherwise. The set of thin children is denoted by and the set of bold children as . A tree-cut decomposition is nice, if for all thin nodes the sets and are disjoint. Any tree-cut decomposition can be transformed into a nice tree-cut decomposition in cubic time [11]. In all notation we leave off the tree-cut decomposition, if it is clear from context. For every graph , we can compute a tree-cut decomposition of width at most in time [20].
Slim Tree-Cut Width.
The slim tree-cut width is defined similarly to tree-cut width. Consider a tree-cut decomposition and . Define the 2-center of with respect to analogous to the 3-center, while only suppressing vertices of degree at most 1.
Definition 3.
The slim width of is defined to be
The slim tree-cut width of is the smallest slim width of any tree-cut decomposition of . Ganian et al. [12] provide an algorithm that, given a graph , computes a tree-cut decomposition of slim width at most in time .
To give perspective on the different parameters considered in this work, we note that treewidth dominates tree-cut width (i.e., bounded tree-cut width implies bounded treewidth) and fracture number, and tree-cut width dominates slim tree-cut width, while (slim) tree-cut width is incomparable with fracture number. We remark that all these parameters model sparse graphs; formally, -vertex graphs where the parameter is bounded have edges.
3 Augmentation for GSTP
The augmented graph for an instance of is defined to be with all terminal pairs connected. That is, the augmented graph is exactly . To extend this notion to an instance of , we consider two different approaches. The clique-augmented graph is obtained from by adding for all an edge between every pair of vertices in . If an edge, that added this way was already present, we obtain parallel edges. As there is a reduction for ensuring that all terminals are unique degree one vertices [10], this definition matches the definition for very closely. On the other hand, the vertex-augmented graph is obtained from by considering each and adding a new vertex to the graph, which is adjacent to all vertices of .
We compare these two definitions for the parameters treewidth, feedback vertex set number, fracture number, vertex cover number, tree-cut width, slim tree-cut width, feedback edge number, and the sum of treewidth and maximum degree. Let be any of these parameters except vertex cover number. Then, we can bound by a function of . For the sum of treewidth and maximum degree, the reverse is possible as well. For the other parameters, the reverse is not possible. For the vertex cover number, there is no function bounding in either direction. In other words, algorithms considering the vertex-augmented graph are almost always more general than those considering the clique-augmented graph, with respect to the parameters considered in this paper. Therefore, we focus on the vertex augmented graph, which, from now on, we call simply the augmented graph, and denote this graph by .
4 GSTP by Augmented Fracture Number
In this section, we lay out our result that is when parameterized by the fracture number of the augmented graph. Let be a fracture modulator of . We achieve this result by showing an equivalence characterization of the components of , which allows us to construct an equivalent ILP instance where number of variables is bounded by a function of . A similar result is known for [14]. We generalize this significantly, while improving the running time from triply exponential to doubly exponential.
Consider any , we call the set of all with by . Let . To better assess, which terminal sets might need special attention, we only consider fracture modulators with a particular structure.
Definition 4.
Let be a fracture modulator of . We call nice, if
-
1.
is edgeless,
-
2.
for each terminal set , there exist two distinct components with and .
Note that even though is edgeless, may contain edges. We show that we can always turn a fracture modulator into a nice fracture modulator of similar size.
Lemma 5.
Let be an instance of and be a fracture modulator of . In linear time, one can construct an equivalent instance and a nice fracture modulator of with and .
From now on, we assume that is a nice fracture modulator for . Each terminal set has its augmented vertex either in , meaning , or in some component , in which case . We also denote with the set of all satisfying , note that by Definition 4. After removing terminal sets with , we reject any instance for which there is a such that . This implies for each that , since the degree of any vertex outside of is less than .
Component Configurations.
In order to fulfill the connectivity requirements, each component might need to use edges from other components, or other components might need to use edges from this component. Denote with the subgraph induced on the component and the fracture modulator. Based on this, we introduce the concept of a component-configuration characterizing how a component can interact with the remaining instance. Let , so has at most edges, and define a configuration of as a tuple with and (if the configuration is clear from context, we omit the index ).
Intuitively, the first part (i.e., ) signifies how often each subset of the fracture modulator gets connected by other components and used for the connection requirements of – what is the additional demand for each subset? The second component (i.e., ) signifies how often each subset of the fracture modulator gets connected inside this component, but these connections are not used to satisfy connection requirements of terminal sets in – what is the additional supply for each subset?
For the final part, consider a terminal set . We have ; so, . This allows us to explicitly store the contribution of to every tree in the solution assigned to such a terminal set. This is necessary since can span an arbitrary number of components in . For each , the information required for the -th tree assigned to is stored in . Call this tree . Let be a surjection. Then, we can imagine for all that is a set of vertices in which can reach via . Note that it might not be all such vertices.
Admitted Configurations.
Not every component can be in any configuration in a valid solution. For example, a component with edges can not supply more than connections to other components. To capture this concept, we say a component admits a configuration if it can locally satisfy all the requirements of the configuration and of the terminal sets in . In order to make this rigorous, we construct an auxiliary instance of to help us define when admits a configuration. For this, let be a surjection, which we use to encode the mapping as explained above. The instance we construct is denoted by .
First, we define the host-graph of the instance . For this, we start with the graph and for each , we add -many vertices to the graph with . Denote this graph with .
Now, we define the terminal sets, that need to be connected. Denote for all , and the set the set of vertices in that is assigned to to satisfy connections for the -th tree of . Now let be the subsets of that get assigned some vertex unioned with the assigned vertices. Let
Note that if consists of exactly one augmented vertex, is empty; otherwise . Further, the set might intersect , but one can verify that is disjoint from and . The complete set of terminal sets, for which we need connections, is .
Finally, we specify the number of required connections . For this extend and to yield 0 or on arguments not in their original domain. For all let
and define .
Definition 6.
We say a component admits a configuration , if there is a surjection such that
-
1.
for all , , and , we have ,
-
2.
there is a solution to such that
-
(a)
for all , we have that ,
-
(b)
for all where is the host-graph of , there is exactly one with and for this , we have ,
-
(c)
for all , we have and is cycle-free.
-
(a)
We say that gives rise to on . With Item 1 we ensure for all that every is connected to a vertex in . Item 2a ensures that the supply claimed by this configuration is satisfied completely inside while Item 2b ensures that connections required from the outside are only used for a single solution tree. Item 2c forbids redundant configurations ensuring that the number of admitted configurations stays singly exponential in .
We call the set of configurations a component admits its signature . We now characterize, whether an instance is solvable solely based on the signatures of its components in . For this, let be a function that assigns each component of a configuration in . We call a configuration selector.
Definition 7.
We call valid, if there is a function such that
-
1.
for all , with we have
-
2.
for all and , the hypergraph is minimally connected,
-
3.
for all and , denote with
all subsets of that are connected for this terminal set. The hypergraph is connected.
In the definition above, the function is used to capture how the requirements of the terminal sets are fulfilled. For a and , gives all connections that are needed for the -th tree assigned to and Item 2 ensures that these connections actually connect . With Item 1 we ensure that there is enough supply to meet the demand. Finally, Item 3 ensures that the stored solutions for the terminal sets are actually connected.
We require minimal connectivity in Item 2 to limit the number of needed variables in our ILP. Note that we cannot require this in Item 3 as this would prevent for any , , and that , which is required in some instances. We show, that a valid configuration selector for exists if and only if is a positive instance.
Lemma 8.
Let be a nice fracture modulator of . Assume that for all we have . Then, the there is a valid configuration selector with respect to if and only if is positive.
Equivalent Configurations.
When building our ILP, we want to treat components with the same signature equally. We call these components equivalent. For each equivalence class, we want to represent all its components by a common set of variables. Now, consider two components such that there exists a graph isomorphism between and preserving , whether a vertex is an augmented vertex, and the demand of such vertices. Then, and are equivalent. Based on this sufficient condition for equivalence, we can calculate that there are no more than non-empty equivalence classes.
Corollary 9.
On there are at most non-empty equivalence classes.
Additionally, we want to use a variable for each configuration in our ILP. So, we need to bound the number of component configurations that we actually need to consider.
Definition 10.
Let be a component-configuration. We call viable, if
The set of all viable configurations is denoted by .
We can prove that any configuration, that is admitted by a component is indeed viable.
Lemma 11.
For all , we have .
By counting the number of viable configurations, we get a bound on the number of variables we will need to encode each configuration. Allowing us to compute the signature of a component by brute-force testing whether this component admits a configuration.
Lemma 12.
For all , we have and we can compute in running time .
ILP Construction.
To construct our ILP, denote with the set of non-empty equivalence classes. For all , denote the signature of any component in with . For all , we create a variable signifying how many components in use the configuration . We ensure for all that . According to Corollaries 9 and 12, This uses variables. Denote with a configuration selector that is encoded by these values . To check Items 1 and 2 of Definition 7, we create for each a variable representing the final value of , amounting to at most many additional variables. First, we ensure that is at most the difference between supply and demand for . Second, let , , and be the set of minimally-connected hypergraphs on the vertex set . We use for each a variable that signifies how often the hypergraph is used to fulfill the demand of . Using this, we can check that each hyper edge is used at most times overall while the demand of is beeing fulfilled. We see that ; meaning, we only introduce additional variables.
To check Item 3 of Definition 7, assume that for all , , as well as , the variable corresponds to the binary indicator whether there is a , and with . If , we create the binary variable . The variable is an indicator for whether is the vertex set of the hypergraph in Item 3 of Definition 7. So, we ensure that there is at most one with and that in any valid assignment . We ensure that is connected using a cut based approach.
Overall, we need variables of type and . This shows, that we can represent the instance as an ILP with variables. As we can find a fracture modulator of minimal size in time, is by the fracture number of the augmented graph. We get thus the main result of this section, stated next.
Theorem 13.
Let be an instance of . We can decide whether is a positive instance in running time .
5 GSTP by Augmented/Slim Tree-Cut Width
In this section, we present an outline of our proof that is by the tree-cut width of the augmented graph as well as the slim tree-cut width of the host graph. Both boil down to solving a dynamic program for a tree-cut decomposition that fulfills some additional assumptions. Note that is by tree-cut width of the host graph, so these additional assumptions are necessary to achieve an algorithm.
Our dynamic program relies on the fact that the number of bold children of any node in our tree-cut decomposition is bounded by a function of its width. Ganian et al. [11] claimed that in a nice tree-cut decomposition the number of bold children of any node is bounded by . In Figure 1, we provide a counter example to this. This shows that in a nice tree-cut decomposition, the number of bold children is actually not bounded by a function of its width. Still, any tree-cut decomposition can be modified in polynomial time to achieve a similar result. The main insight behind this result is that the bold nodes that are not present in the 3-center form a path like the one seen in Figure 1.
Corollary 14.
Any tree-cut decomposition can be altered in polynomial time to ensure that it becomes nice and for all , we have . We call such a tree-cut decomposition friendly.
Based on this, we give the definition of a simple tree-cut decomposition.
Definition 15.
Consider a tree-cut decomposition of and let . Denote with the set of terminal sets crossing the link between and its parent. We call simple if it is thin, , , and . We call simple, if it is friendly and all thin nodes are simple.
5.1 GSTP by a Simple Tree-Cut Decomposition
Assume we are given a simple tree-cut decomposition for of width . For all , the thin children of mostly act like subdivided edges inside . To limit the number of trees that we need to consider crossing , define .
Reduction Rule 16.
If there is a node with , output a trivial negative instance.
If we apply Reduction Rule 16, we can now choose for each a function such that for all we have . This function gives us the ability to identify the different trees crossing the link between this node and its parent by a number in the set . Based on this, we obtain a dynamic program for deciding the instance in time with respect to .
The Data-Table.
The data-table at , is a set of tuples , each consisting of three parts: , , and with . Each of and are partitions of a (not necessarily proper) subset of . If and are disjoint, we call syntactically valid. Note that we do not assign the partitions in to indices, since at this point we do not care, whether they are eventually used for the same terminal set.
Intuitively, a tuple gives almost complete information about the part of the final solution that crosses . Consider a solution to the whole instance and denote with the trees containing an edge of . Set and as the subgraphs crossing the link between and its parent, which are assigned to terminal set starting below this link and starting above this link, respectively. Let be the graph edge-induced by all edges with at least one endpoint in . This solution corresponds to a tuple with and where we consider the edges in per connected component of the trees in restricted to the edges incident to . For each , we choose a distinct such that if , we have and and if , we have . Now, we set to for each set induced by .
Consider a syntactically valid tuple . To formally define what is supposed to mean, let . Note that and are disjoint and their union is the set of all terminals that are not disjoint from . We add vertices to such that each has the neighborhood . Call this graph . These additional vertices can be used to simulate that a subgraph gets connected outside . Let and denote with the vertices in of the terminal set assigned to the -th subgraph crossing combined with . Additionally, define for each the set to be all vertices of edges contained in that are not in . Finally, define the instance , where for all we have , for all , we have , and for all , we have .
Definition 17.
For each the data-table is the set of syntactically valid tuples at where the instance has a solution such that
-
1.
we have ,
-
2.
for all and , the set is disjoint from ,
-
3.
for all , there is a with ,
-
4.
for all , let , then
-
if , we have ,
-
otherwise, there is exactly one with and this additionally satisfies that can be partitioned into such that for all , the graph is connected and .
-
With Item 1 we ensure that the edges used in the solution are accounted for in and . We want to be able to assume that for every there is a subgraph completely contained in connecting all edges of . So, in Item 2 we ensure that the vertices – that are used to simulate that a subgraph gets connected outside of this graph – are not included in the subgraphs connecting the edges in . These subgraphs should also use exactly the edge-set in , which we ensure with Item 3. Finally, consider Item 4 and . If , that is, no edges are assigned to the -th subgraph, the vertex , which is used to mark the -th subgraph crossing , is not used in any subgraph. Otherwise, we again ensure that for each there is a subgraph in this solution that connects the edges of inside . Notice that we can combine Items 1, 3, and 4 to show, that for any with there is a with .
Immediately, we observe that this dynamic program can indeed be used to determine whether is a positive instance, by checking for the root of whether .
Computing the Data-Table.
To compute this dynamic program, we assume that for all bold children of , we have already computed the data-table . We now outline how to compute in -time. As the number of syntactically valid tuples is in , it is enough to decide in -time for a given syntactically valid tuple whether . For this we iterate over all simultaneous choices of for and check whether the solutions witnessing can be extended to solutions witnessing .
Assume for all a is fixed. To combine the subgraphs of the sub-solutions witnessing to a solution witnessing , we need to translate the local numberings of the solution subgraphs into a numbering shared across all solution subgraphs not fully contained in one connected component of . When dealing with a shared mapping, we need to avoid that we map solution subgraphs assigned to different terminal sets to the same index. Let and denote with the set of terminal sets completely contained in , and with the set of all terminal sets, which are not completely contained in one sub-tree of . Note that this claim holds for as none of their terminal vertices occur in any sub-tree of . As is simple, has at most bold children. So, is an upper bound on the total demand of all terminal sets crossing the links between and its parent or any of its bold children. It is also an upper bound on the number of edges crossing bold links adjacent to . So, we need at most shared indices for the crossing subgraphs. Based on these observations, we can carefully construct a mapping from the local numberings to a shared numbering. Given such a mapping, we can construct instances with augmented fracture number at most to decide whether this mapping gives a viable extension.
Theorem 18.
Given a simple tree-cut decomposition of width , we can decide whether the instance is positive in time .
However, we can not assume, in general, that is simple. If is already close to simple everywhere, we can make simple without increasing its width too much. Let and denote with the set of thin and non-simple children of . If for all both and are small, we obtain a simple tree-cut decomposition of only slightly increased width. The main idea is to treat non-simple thin children like bold children.
Lemma 19.
Let . We can compute in linear time an equivalent instance and a simple tree-cut decomposition of with width
5.2 GSTP by Slim Tree-Cut Width
We now show that is by the slim tree-cut width of . This is a direct application of Lemma 19. For this, denote with the slim width of . We mostly need to take care of thin links with adhesion one.
Reduction Rule 20.
Assume that Reduction Rule 16 was applied. Let with and consider with and . Remove from and if there is a , increase the demand of and by 1 while removing from (if necessary, add and to ).
After applying Reduction Rules 16 and 20 exhaustively and considering connected components separately, all links have adhesion at least two. This can be used to prove that for all , we have . As , we have . This allows us to apply Lemma 19 and obtain a simple tree-cut decomposition of width at most . There is an algorithm that computes a tree-cut decomposition of slim width at most in time [12]. Combined with Theorem 18, we obtain that is by the slim tree-cut width of the host graph.
Corollary 21.
Let be an instance of . We can decide whether is positive in time .
5.3 GSTP by Tree-Cut Width of the Augmented Graph
Solving parameterized by the tree-cut width of the augmented graph also boils down to solving instances of with a simple tree-cut decomposition. From now on, assume that is a tree-cut decomposition of with width . Set and let for all . Then, is a tree-cut decomposition of with width at most . When we refer to Reduction Rules 16 and 20, we mean that they are applied with respect to while keeping in sync. These reduction rules already bring us quite close to being simple with respect to the nodes that are thin in .
Lemma 22.
After exhaustively applying Reduction Rules 16 and 20 with respect to , removing nodes that are empty in and and splitting the instance by connected components, we have for all that are thin in that and . In particular, does not contain an augmented and a non-augmented edge. Additionally, the tree-cut decompositions can be maintained efficiently while not increasing the width of and keeping friendly if it was friendly before.
There are two obstacles remaining before we can show that is by the tree-cut width of the augmented graph. First, we need to ensure for all thin nodes that . We call nodes that are thin in , but have cluttered. Second, we need to take care of all nodes that are bold in , but thin in . As is friendly, for each the number of such children is bounded by the number of bold children. So, this task can be taken care of rather quickly by applying Lemma 19.
Lemma 23.
Assume is friendly, has no cluttered nodes, that Reduction Rule 20 was applied exhaustively, and that the instance is split by connected components. We can compute in linear time an equivalent instance and a simple tree-cut decomposition of of width at most .
To tackle the cluttered nodes, we solve sub-instances of . The reduction rules we present now, are no reduction rules in the classical sense (i.e., they do not run in polynomial time), but rather recursion rules. We later show, how to apply these rules in a way, that we only solve simple sub-instances and mostly preserve the running time obtained in Theorem 18.
The crux of why this problem is by the tree-cut width of the augmented graph, but by the tree-cut width of the host-graph [13] lies in the fact, that for a cluttered node , we have for all that either or is empty. This means that no terminal set crosses . Therefore, we can mostly disregard how the instance looks on for deciding how terminal sets contained in are solved in a solution of the whole instance. Let and be such, that , and let be the terminal sets contained in . Note that . First, we consider the case, where we can satisfy the requirements of , while supplying an additional connection for to , while solving the requirements of .
Reduction Rule 24.
Consider the instance where is increased by one for the argument . If is positive, remove all from and contract in the original instance .
If Reduction Rule 24 is not applicable, we know that we cannot use and in a tree for terminals contained in . So, we check, whether the terminal sets can be solved only using edges of .
Reduction Rule 25.
Assume that Reduction Rule 24 is not applicable to . Consider the instance . If is positive, remove from and from in the original instance .
Finally, we need to take care of the case, where the terminal sets cannot be solved using only edges of .
Reduction Rule 26.
Assume both Reduction Rules 24 and 25 are not applicable to . Consider the instance . If is positive, we remove from , from , and add 1 demand to the terminal set in the remaining instance (if necessary, add to ). Otherwise, output a trivial negative instance.
The tree-cut width of the augmented graphs of , and is at most and applying any of Reduction Rules 24, 25, and 26 does not increase the tree-cut width of the augmented graph. Together, these reduction rules can be used to remove a cluttered node – or at least make it non-cluttered. To solve parameterized by the tree-cut width of the augmented graph, we solve multiple sub-instances of with respect to simple tree-cut decompositions. The basic idea is to consider a cluttered node with . If such a node does not exist, we either re-root, or we are able to directly find a simple tree-cut decomposition of width . Now, we check recursively which of Reduction Rules 24, 25, and 26 is applicable. By choice of , we can ensure that overall at most many simple instances are solved.
Theorem 27.
Assume can be solved in time , given a graph of size at most and a simple tree-cut decomposition of width at most . Let be an instance of . Given a tree-cut decomposition of width for , we can decide whether is positive in time .
Kim et al. [20] proved that for all graphs we can compute a tree-cut decomposition of width in time . Combined with Theorem 18, we know that is FPT by the tree-cut width of the augmented graph.
Corollary 28.
Let be an instance of . We can decide whether this instance is positive in time .
6 STP by Tree-Cut Width
To show, how to decide an instance of parameterized by , let be a friendly tree-cut decomposition of width . If , we interpret as an instance of . Consider the tree-cut decomposition for , obtained by adding a new root containing to , and making the old root a child of . The adhesion of is bounded by . Let . Any with is also a thin child of in . Thus, . Note that the torso at in consists of 2 vertices. Thus, the width of is bounded by and we can use Corollary 28 to decide whether the instance is positive in -time.
The same approach does not work for the case , as in this case, the tree-cut width of the augmented graph is not necessarily bounded by a function of the tree-cut width of the host graph. For this consider as the host graph a path of length where we attach to each vertex of the path 3 leaves. This graph is a tree, has tree-cut width 1, and is depicted in Figure 2. If we take all leaves to be the terminal set, the augmented graph, depicted in Figure 2, has tree-cut width at least [27].
Remark 29.
There exists a family of instances such that the host-graph of every instance has tree-cut width 1, but the tree-cut width of the augmented graph of the instances is not bounded.
In this case (i.e., ), we observe that is not contained in a single bag. By Reduction Rule 16, we can assume that . As , the parameter is bounded by a function of . So, if we can solve parameterized by this parameter, we obtain an algorithm for parameterized by tree-cut width of the original graph. As it turns out, we can even solve by a similar parameter using a dynamic program on the tree decomposition.
Theorem 30.
Let be an instance of the problem and set . In time , we can decide whether this instance is positive.
We remark that this algorithm directly improves upon the known algorithm for EDP with respect to the parameter [29].
Combined with the case distinction for , that in time we can find a tree-cut decomposition of width [20], and Corollary 28 we get that is by the parameter .
Corollary 31.
Let be an instance of . In time , we can decide whether this instance is positive.
7 Conclusion and Outlook
In this paper, we provide the first fixed-parameter tractable algorithm for Steiner Tree Packing () parameterized by a structural parameter. Concretely, we show that is when parameterized by fracture number as well as tree-cut width. This significantly extends the number of instances for which we know an exact polynomial time algorithm. Previously known polynomial time algorithms are typically based on heuristics or approximations. In case of the result that is by , we do not even know a concrete algorithm, but only that one exists [26].
To achieve this goal, we generalize the notion of the augmented graph from Edge-Disjoint Paths () to Generalized Steiner Tree Packing () and . This is the first result utilizing this tool on a problem where the terminals are arbitrary sets and not pairs of vertices. The notion of augmentation has been used extensively for , but was originally introduced for Multicut [16]. Despite the fact that many parameterized complexity results for the generalized version of this problem (Steiner Multicut) are known [4], the augmented graph has not yet been considered in this setting. We think that augmentation will also prove to be a valuable tool for Steiner Multicut and other similar problems in future research.
Further, we extend all known algorithms for parameterized by a structural parameter to . In addition, we provide a novel algorithm for parameterized by the tree-cut width of the augmented graph. This settles whether is or parameterized by all eight commonly used structural parameters described in Section 2 with respect to the augmented graph as well as the host graph. As all these results coincide between and , this also completes such a complexity classification for , where previously the result that is by the tree-cut width of the augmented graph was not known.
For the established results are almost as complete. We prove for six of these eight parameters that is . It is known, that is parameterized by treewidth, even if [2, 1]. So, the only question remaining here is whether is parameterized by feedback vertex set number. As is parameterized by the feedback vertex set number of the augmented graph [14], the approach employed in this paper – generalizing results from to and applying them to – is not suited to decide this questions. Also, the techniques used by Bodlaender et al. [2] to obtain the ness result for Integer 2-Commodity Flow parameterized by treewidth, which generalizes to with [1], do not easily apply with respect to the feedback vertex set number. We leave answering this question to future research.
References
- [1] Ashkan Aazami, Joseph Cheriyan, and Krishnam Raju Jampani. Approximation algorithms and hardness results for packing element-disjoint steiner trees in planar graphs. Algorithmica, 63(1-2):425–456, 2012. doi:10.1007/S00453-011-9540-3.
- [2] Hans L. Bodlaender, Isja Mannens, Jelle J. Oostveen, Sukanya Pandey, and Erik Jan van Leeuwen. The parameterised complexity of integer multicommodity flow. In 18th International Symposium on Parameterized and Exact Computation, IPEC 2023, September 6-8, 2023, Amsterdam, The Netherlands, pages 6:1–6:19, 2023. doi:10.4230/LIPIcs.IPEC.2023.6.
- [3] Cornelius Brand, Esra Ceylan, Robert Ganian, Christian Hatschka, and Viktoriia Korchemna. Edge-cut width: An algorithmically driven analogue of treewidth based on edge cuts. In Graph-Theoretic Concepts in Computer Science - 48th International Workshop, WG 2022, Tübingen, Germany, June 22-24, 2022, Revised Selected Papers, pages 98–113, 2022. doi:10.1007/978-3-031-15914-5_8.
- [4] Karl Bringmann, Danny Hermelin, Matthias Mnich, and Erik Jan van Leeuwen. Parameterized complexity dichotomy for steiner multicut. In 32nd International Symposium on Theoretical Aspects of Computer Science, STACS 2015, March 4-7, 2015, Garching, Germany, pages 157–170, 2015. doi:10.4230/LIPIcs.STACS.2015.157.
- [5] Michael Burstein and Richard N. Pelavin. Hierarchical wire routing. IEEE Trans. Comput. Aided Des. Integr. Circuits Syst., 2(4):223–234, 1983. doi:10.1109/TCAD.1983.1270040.
- [6] S. Chen, O. Gunluk, and B. Yener. Optimal packing of group multicastings. In Proceedings. IEEE INFOCOM ’98, the Conference on Computer Communications. Seventeenth Annual Joint Conference of the IEEE Computer and Communications Societies. Gateway to the 21st Century (Cat. No.98, volume 3, pages 980–987 vol.3, 1998. doi:10.1109/INFCOM.1998.662907.
- [7] James P. Cohoon and Patrick L. Heck. BEAVER: a computational-geometry-based tool for switchbox routing. IEEE Trans. Comput. Aided Des. Integr. Circuits Syst., 7(6):684–697, 1988. doi:10.1109/43.3208.
- [8] Matt DeVos, Jessica McDonald, and Irene Pivotto. Packing steiner trees. J. Comb. Theory B, 119:178–213, 2016. doi:10.1016/J.JCTB.2016.02.002.
- [9] Pavel Dvorák, Eduard Eiben, Robert Ganian, Dusan Knop, and Sebastian Ordyniak. The complexity landscape of decompositional parameters for ILP: programs with few global variables and constraints. Artif. Intell., 300:103561, 2021. doi:10.1016/J.ARTINT.2021.103561.
- [10] Krzysztof Fleszar, Matthias Mnich, and Joachim Spoerhase. New algorithms for maximum disjoint paths based on tree-likeness. Math. Program., 171(1):433–461, September 2018. doi:10.1007/s10107-017-1199-3.
- [11] Robert Ganian, Eun Jung Kim, and Stefan Szeider. Algorithmic applications of tree-cut width. SIAM J. Discret. Math., 36(4):2635–2666, 2022. doi:10.1137/20M137478X.
- [12] Robert Ganian and Viktoriia Korchemna. Slim tree-cut width. In 17th International Symposium on Parameterized and Exact Computation, IPEC 2022, September 7-9, 2022, Potsdam, Germany, pages 15:1–15:18, 2022. doi:10.4230/LIPIcs.IPEC.2022.15.
- [13] Robert Ganian and Sebastian Ordyniak. The power of cut-based parameters for computing edge-disjoint paths. Algorithmica, 83(2):726–752, October 2020. doi:10.1007/s00453-020-00772-w.
- [14] Robert Ganian, Sebastian Ordyniak, and M. S. Ramanujan. On structural parameterizations of the edge disjoint paths problem. Algorithmica, 83(6):1605–1637, 2021. doi:10.1007/s00453-020-00795-3.
- [15] Naveen Garg, Rohit Khandekar, Keshav Kunal, and Vinayaka Pandit. Bandwidth maximization in multicasting. In Algorithms - ESA 2003, 11th Annual European Symposium, Budapest, Hungary, September 16-19, 2003, Proceedings, pages 242–253, 2003. doi:10.1007/978-3-540-39658-1_24.
- [16] Georg Gottlob and Stephanie Tien Lee. A logical approach to multicut problems. Inf. Process. Lett., 103(4):136–141, 2007. doi:10.1016/J.IPL.2007.03.005.
- [17] Martin Grötschel, Alexander Martin, and Robert Weismantel. The steiner tree packing problem in VLSI design. Math. Program., 77:265–281, 1997. doi:10.1007/BF02614374.
- [18] Niko Hastrich and Kirill Simonov. Structural parameterization of steiner tree packing. CoRR, abs/2505.09250, 2025. doi:10.48550/arXiv.2505.09250.
- [19] Petteri Kaski. Packing steiner trees with identical terminal sets. Inf. Process. Lett., 91(1):1–5, 2004. doi:10.1016/j.ipl.2004.03.006.
- [20] Eun Jung Kim, Sang-il Oum, Christophe Paul, Ignasi Sau, and Dimitrios M. Thilikos. An FPT 2-approximation for tree-cut decomposition. Algorithmica, 80(1):116–135, 2018. doi:10.1007/S00453-016-0245-5.
- [21] Matthias Kriesell. Edge-disjoint trees containing some given vertices in a graph. J. Comb. Theory B, 88(1):53–65, 2003. doi:10.1016/S0095-8956(02)00013-8.
- [22] W. K. Luk. A greedy switch-box router. Integr., 3(2):129–149, 1985. doi:10.1016/0167-9260(85)90029-X.
- [23] A. Martin and R. Weismantel. Packing paths and steiner trees: routing of electronic circuits. CWI Quarterly, 6(3):185–204, September 1993.
- [24] Yoram Ofek and Bülent Yener. Reliable concurrent multicast from bursty sources. IEEE J. Sel. Areas Commun., 15(3):434–444, 1997. doi:10.1109/49.564140.
- [25] William R. Pulleyblank. Two steiner tree packing problems (extended abstract). In Proceedings of the Twenty-Seventh Annual ACM Symposium on Theory of Computing, 29 May-1 June 1995, Las Vegas, Nevada, USA, pages 383–387, 1995. doi:10.1145/225058.225163.
- [26] Neil Robertson and Paul D. Seymour. Graph minors .xiii. the disjoint paths problem. J. Comb. Theory, Ser. B, 63(1):65–110, 1995. doi:10.1006/JCTB.1995.1006.
- [27] Paul Wollan. The structure of graphs not admitting a fixed immersion. J. Comb. Theory, Ser. B, 110:47–66, 2015. doi:10.1016/J.JCTB.2014.07.003.
- [28] Miao Zhao, Bin Jia, Mingquan Wu, Heather Yu, and Yang Xu. Software defined network-enabled multicast for multi-party video conferencing systems. In 2014 IEEE International Conference on Communications (ICC), pages 1729–1735, 2014. doi:10.1109/ICC.2014.6883572.
- [29] Xiao Zhou, Syurei Tamura, and Takao Nishizeki. Finding edge-disjoint paths in partial k-trees. Algorithmica, 26(1):3–30, 2000. doi:10.1007/s004539910002.
