Abstract 1 Introduction 2 Preliminaries 3 Augmentation for GSTP 4 GSTP by Augmented Fracture Number 5 GSTP by Augmented/Slim Tree-Cut Width 6 STP by Tree-Cut Width 7 Conclusion and Outlook References

Structural Parameterization of Steiner Tree Packing

Niko Hastrich ORCID Saarland University and Max Planck Institute for Informatics, Saarland Informatics Campus, Saarbrücken, Germany Kirill Simonov ORCID Department of Informatics, University of Bergen, Norway
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 tractability
Funding:
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:
[Uncaptioned image] © Niko Hastrich and Kirill Simonov; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Fixed parameter tractability
; Theory of computation Graph algorithms analysis
Related Version:
Full Version: https://arxiv.org/abs/2505.09250 [18]
Funding:
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ắng

1 Introduction

In Steiner tree packing (𝖲𝖳𝖯), we are given a triple (G,T,d), where G is a graph, TV(G) is the terminal set, and d+ is the demand. The goal is to decide whether there are d edge-disjoint trees F1,F2,,Fd in G which all contain the vertices T. It is easy to see that the problem is polynomial-time solvable if |T|2 or d=1. However, even for |T|3 or d2, 𝖲𝖳𝖯 is already 𝖭𝖯-hard [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 d edge-disjoint subgraphs connecting T, T is clearly d-edge-connected. On the other, Kriesell [21] conjectured that if T is 2d-edge-connected, then G contains d edge-disjoint trees connecting T. While the conjecture remains open, we know that (5d+4)–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 2-approximate algorithm for 𝖲𝖳𝖯.

The situation with exact polynomial-time algorithms for 𝖲𝖳𝖯 is considerably more restrictive. As discussed above, in terms of the size |T| of the terminal set and the demand d, 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 |T|+d. However, this result is non-constructive and the running time as a function of |T|+d 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 𝖶[1]-hard parameterized by treewidth [2]. Thus, 𝖲𝖳𝖯 is also 𝖶[1]-hard parameterized by treewidth, even on instances where the terminal set T 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 (G,𝒯), where G is a graph and 𝒯(V(G)2) is a set of terminal pairs in V(G). The task is to decide whether for each {u,v}𝒯 there is an uv-path Puv in G such that all {Puv}{u,v}𝒯 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 𝖭𝖯-hard 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 G, but rather to the augmented graph G+𝒯, 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 𝖭𝖯-hard 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 (G,𝒯,d), where G is the underlying graph, 𝒯2V(G) is the set of terminal sets, and d:𝒯+ gives the demand for each terminal set. Our task is to decide whether there is a set of pairwise edge-disjoint, connected subgraphs of G and an assignment function π:𝒯 such that every solution subgraph F is assigned to a terminal set π(F), which is contained in F (i.e., π(F)V(F)). Additionally, for every terminal set T𝒯, the assignment function needs to assign d(T) many solution subgraphs to T. 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.

Table 1: The parameterized complexity of 𝖲𝖳𝖯, 𝖤𝖣𝖯, and 𝖦𝖲𝖳𝖯 with respect to structural parameters of the host graph or the augmented graph. See Section 2 for parameter definitions. The value D is the sum of demands. New results are highlighted with the symbol , results where we improve the running time are highlighted with . We abbreviate -hard with -h.
𝗦𝗧𝗣 𝗘𝗗𝗣 𝗚𝗦𝗧𝗣
Host Aug. Host Aug. Host Aug.
tw 𝖶[1]-h1h 𝗉𝖺𝗋𝖺𝖭𝖯-h 𝖶[1]-h1h 𝗉𝖺𝗋𝖺𝖭𝖯-h 𝖶[1]-h1h
[1, 2] [10] [14] [10] [14]
tw+D 𝖥𝖯𝖳 𝖥𝖯𝖳 𝖥𝖯𝖳
Theorem 30 Theorem 30 Theorem 30
fn 𝖥𝖯𝖳 𝗉𝖺𝗋𝖺𝖭𝖯-h 𝖥𝖯𝖳 𝗉𝖺𝗋𝖺𝖭𝖯-h 𝖥𝖯𝖳
Theorem 13 [10] Theorem 13 [10] Theorem 13
tcw 𝖥𝖯𝖳 𝖶[1]-h1h 𝖥𝖯𝖳 𝖶[1]-h1h 𝖥𝖯𝖳
Corollary 31 [13] Corollary 28 [13] Corollary 28
stcw 𝖥𝖯𝖳 𝖥𝖯𝖳 𝖥𝖯𝖳
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 𝗉𝖺𝗋𝖺𝖭𝖯-hard 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 ={0,1,2,} and the positive natural numbers by +. Let k, let [k]{1,2,,k} and [k]0={0}[k]. For any set S, we denote with 2S its power-set. Let G be a graph. Unless explicitly stated otherwise, we only consider simple graphs. Let SV(G), we refer to the edges with exactly one endpoint in S by δG(S). Let uvE(G), contracting uv merges u and v into a single vertex, while keeping vertices adjacent to u or v adjacent to the combined vertex. Similarly, contracting a vertex set SV(G) merges all the vertices in S into a single vertex, while keeping vertices adjacent to at least one vertex of S adjacent to the new vertex. Let vV(G), suppressing v is the operation of inserting edges between all neighbors of v and removing v. The set of maximally connected subgraphs of G is denoted with comp(G). Let H be a hypergraph. H 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 G on vertex-sets of G, we refer to the vertices of G as nodes or bags and to its edges by links.

Fracture Number.

Let SV(G). We call S a fracture modulator if every component in GS contains at most |S| vertices. The size of the smallest fracture modulator is called the fracture number fn(G) of G. Dvorák et al. [9] claim that for any graph H, one can find a fracture modulator of minimal size in time 𝒪((fn(H)+1)fn(H)|E(H)|). We note that their proof suffers from a minor inaccuracy, and present a corrected version that runs in time 𝒪((2fn(H)1)fn(H)|V(H)|), 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 G is a tuple 𝒟(T,𝒳), where T is a rooted tree and {XsV(G)sV(T)}𝒳 a near-partition of V(G).

Here, subsets in a near-partition may be empty, as opposed to a partition. For a node tV(T), let Tt𝒟 be the sub-tree rooted at t and we set Yt𝒟sTt𝒟Xs to be the vertices contained in the bags of Tt𝒟. Let tG[δ(Yt𝒟)] be the graph induced by all edges crossing the link between t and its parent, which we refer to as the boundary at t. The adhesion adh𝒟(t) of t is defined as |E(t)|.

The torso of a tree-cut decomposition at node t, denoted as Ht𝒟, is the graph obtained from G as follows. Consider the connected components of Tt and for each Ccomp(Tt), define ZCsV(C)Xs. The torso at t is obtained from G by contracting for all Ccomp(Tt) the sets ZC into a single vertex zC. Note that this may create parallel edges. Consider the unique graph H~t𝒟, obtained from Ht𝒟, by repeatedly suppressing vertices not in Xt of degree at most 2 and removing loops. H~t𝒟 is called the 3-center of Ht𝒟 with respect to Xt.

Definition 2.

The width of the tree-cut decomposition is

max({adh(s)}sV(T){|V(H~s𝒟)|}sV(T)).

The tree-cut width tcw(G) of G is the smallest width of a tree-cut decomposition. We call t empty if Xt= and we denote with chil(t) the set of children of t in T. We call t thin if adh𝒟(t)2 and bold otherwise. The set of thin children is denoted by t-chil𝒟(t) and the set of bold children as b-chil𝒟(t). A tree-cut decomposition is nice, if for all thin nodes t the sets NG(Yt) and s is a sibling of tYs𝒟 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 G, we can compute a tree-cut decomposition of width at most 2tcw(G) in time 2𝒪(tcw(G)2logtcw(G))|V(G)|2 [20].

Slim Tree-Cut Width.

The slim tree-cut width is defined similarly to tree-cut width. Consider a tree-cut decomposition 𝒟=(T,𝒳) and tV(T). Define the 2-center H~t2;𝒟 of Ht𝒟 with respect to Xt analogous to the 3-center, while only suppressing vertices of degree at most 1.

Definition 3.

The slim width of 𝒟 is defined to be

max({adh(t)}sV(T){|V(H~s2,𝒟)|}sV(T)).

The slim tree-cut width stcw(G) of G is the smallest slim width of any tree-cut decomposition of G. Ganian et al. [12] provide an algorithm that, given a graph G, computes a tree-cut decomposition of slim width at most 6(stcw(G)+1)3 in time 2𝒪(stcw(G)2logstcw(G))|V(G)|4.

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, n-vertex graphs where the parameter is bounded have 𝒪(n) edges.

3 Augmentation for GSTP

The augmented graph for an instance (G,𝒯) of 𝖤𝖣𝖯 is defined to be G with all terminal pairs connected. That is, the augmented graph G𝒯 is exactly G+𝒯. To extend this notion to an instance (G,𝒯,d) of 𝖦𝖲𝖳𝖯, we consider two different approaches. The clique-augmented graph Gcliq(𝒯) is obtained from G by adding for all T𝒯 an edge between every pair of vertices in T. 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 Gvert(𝒯) is obtained from G by considering each T𝒯 and adding a new vertex aug(T) to the graph, which is adjacent to all vertices of T.

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 κ(Gvert(𝒯)) by a function of κ(Gcliq(𝒯)). 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 G𝒯.

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 X be a fracture modulator of G𝒯. We achieve this result by showing an equivalence characterization of the components of G𝒯X, which allows us to construct an equivalent ILP instance where number of variables is bounded by a function of |X|. A similar result is known for 𝖤𝖣𝖯 [14]. We generalize this significantly, while improving the running time from triply exponential to doubly exponential.

Consider any UV(G𝒯), we call the set of all T𝒯 with aug(T)U by 𝒯U. Let Ccomp(G𝒯X). To better assess, which terminal sets might need special attention, we only consider fracture modulators with a particular structure.

Definition 4.

Let XV(G𝒯) be a fracture modulator of G𝒯. We call X nice, if

  1. 1.

    G[X] is edgeless,

  2. 2.

    for each terminal set T𝒯X, there exist two distinct components C,Ccomp(G𝒯X) with V(C)T and V(C)T.

Note that even though G[X] is edgeless, G𝒯[X] may contain edges. We show that we can always turn a fracture modulator into a nice fracture modulator of similar size.

Lemma 5.

Let 𝒫(G,𝒯,d) be an instance of 𝖦𝖲𝖳𝖯 and X be a fracture modulator of G𝒯. In linear time, one can construct an equivalent instance 𝒫=(G,𝒯,d) and a nice fracture modulator S of G𝒯 with |S|2|X| and |V(G)||V(G)|+(|X|2)+2|X|.

From now on, we assume that S is a nice fracture modulator for (G,𝒯,d). Each terminal set T has its augmented vertex aug(T) either in S, meaning T𝒯S, or in some component Ccomp(G𝒯S), in which case T𝒯C. We also denote with 𝒯 the set of all T𝒯 satisfying TS, note that 𝒯𝒯S= by Definition 4. After removing terminal sets T with |T|<2, we reject any instance for which there is a vV(G) such that degG(v)<T𝒯:vTd(T). This implies for each T𝒯𝒯 that d(T)<2|S|, since the degree of any vertex outside of S is less than 2|S|.

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 C+G𝒯[V(C)S] 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 Ccomp(G𝒯S) can interact with the remaining instance. Let u(2|S|2), so C+ has at most u edges, and define a configuration γ of C as a tuple (demγ,suplγ,assignγ) with demγ,suplγ:2SV(G)[u]0 and assignγ:𝒯S×[2|S|]×[|S|]2SV(G) (if the configuration is clear from context, we omit the index γ).

Intuitively, the first part (i.e., dem) signifies how often each subset of the fracture modulator gets connected by other components and used for the connection requirements of 𝒯C – what is the additional demand for each subset? The second component (i.e., supl) 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 𝒯C – what is the additional supply for each subset?

For the final part, consider a terminal set T𝒯S. We have T𝒯; so, d(T)2|S|. This allows us to explicitly store the contribution of C to every tree in the solution assigned to such a terminal set. This is necessary since T can span an arbitrary number of components in G𝒯S. For each i[d(T)], the information required for the i-th tree assigned to T is stored in assign(T,i,). Call this tree Fi. Let σ:[|S|]V(C) be a surjection. Then, we can imagine for all j[|S|] that assign(T,i,j) is a set of vertices in S which σ(j) can reach via Fi[V(C+)]. 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 k edges can not supply more than k 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 𝒯C. In order to make this rigorous, we construct an auxiliary instance of 𝖦𝖲𝖳𝖯 to help us define when C admits a configuration. For this, let σ:[|S|]V(C) be a surjection, which we use to encode the assign mapping as explained above. The instance we construct is denoted by confInst(C,γ,σ).

First, we define the host-graph of the instance confInst(C,γ,σ). For this, we start with the graph C+ and for each QSV(G), we add dem(Q)-many vertices v to the graph with N(v)=Q. Denote this graph with H.

Now, we define the terminal sets, that need to be connected. Denote for all T𝒯S, i[d(T)] and USV(G) the set A(T,i,U,σ){σ(j)j[|S|];assign(T,i,j)=U} the set of vertices in C that is assigned to U to satisfy connections for the i-th tree of T. Now let assignSets(T,i,σ)USV(G):A(T,i,U,σ){UA(T,i,U,σ)} be the subsets of SV(G) that get assigned some vertex unioned with the assigned vertices. Let

𝒬 {T𝒯CTC},
𝒮 {XSV(G)supl(X)>0},
𝒜 T𝒯S,i[d(T)]assignSets(T,i,σ).

Note that if C consists of exactly one augmented vertex, 𝒬 is empty; otherwise 𝒬=𝒯C. Further, the set 𝒜 might intersect Q, but one can verify that 𝒮 is disjoint from 𝒜 and Q. The complete set of terminal sets, for which we need connections, is 𝒰Q𝒮𝒜.

Finally, we specify the number of required connections d:𝒰+. For this extend d, supl and assign to yield 0 or on arguments not in their original domain. For all U𝒰 let

d(U)d(U)+supl(U)+T𝒯S|{i[d(T)]UassignSets(T,i,σ)}|,

and define confInst(C,γ,σ)=(H,𝒰,d).

Definition 6.

We say a component Ccomp(G𝒯S) admits a configuration γ, if there is a surjection σ:[|S|]V(C) such that

  1. 1.

    for all T𝒯𝒮, i[d(T)], and jσ1(TV(C)), we have assign(T,i,j),

  2. 2.

    there is a solution (,π) to confInst(C,γ,σ) such that

    1. (a)

      for all Fπ1(𝒮), we have that V(F)V(C+),

    2. (b)

      for all vV(H)V(C+) where H is the host-graph of confInst(C,γ,σ), there is exactly one F with vV(F) and for this F, we have degF(v)2,

    3. (c)

      for all F, we have E(C+)E(F) and F is cycle-free.

We say that (σ,,π) gives rise to γ on C. With Item 1 we ensure for all T𝒯S that every vTV(C) is connected to a vertex in SV(G). Item 2a ensures that the supply claimed by this configuration is satisfied completely inside C+ 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 |S|.

We call the set of configurations a component admits its signature sig(C). We now characterize, whether an instance is solvable solely based on the signatures of its components in G𝒯S. For this, let Γ be a function that assigns each component of Ccomp(G𝒯S) a configuration in sig(C). We call Γ a configuration selector.

Definition 7.

We call Γ valid, if there is a function ρ:2SV(G)×22SV(G) such that

  1. 1.

    for all USV(G), with rU|{(T,i)𝒯×Uρ(T,i)}| we have

    rU+Ccomp(G𝒯S)demΓ(C)(U)Ccomp(G𝒯S)suplΓ(C)(U),
  2. 2.

    for all T𝒯 and i[d(T)], the hypergraph (Tρ(T,i),ρ(T,i)) is minimally connected,

  3. 3.

    for all T𝒯S and i[d(T)], denote with

    {assignΓ(C)(T,i,j)Ccomp(G𝒯S),j[|S|]}

    all subsets of S that are connected for this terminal set. The hypergraph ((TS),) is connected.

In the definition above, the function ρ is used to capture how the requirements of the terminal sets 𝒯 are fulfilled. For a T𝒯 and i[d(T)], ρ(T,i) gives all connections that are needed for the i-th tree assigned to T and Item 2 ensures that these connections actually connect T. 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 𝒯S 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 T𝒯S, id(T), and j[|S|] that |assign(T,i,j)|=1, 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 S be a nice fracture modulator of G𝒯. Assume that for all vV we have T𝒯:vTd(T)degG(v). Then, the there is a valid configuration selector with respect to S 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 C1,C2comp(G𝒯S) such that there exists a graph isomorphism between C1+ and C2+ preserving S, whether a vertex is an augmented vertex, and the demand of such vertices. Then, C1 and C2 are equivalent. Based on this sufficient condition for equivalence, we can calculate that there are no more than 2𝒪(|S|2) non-empty equivalence classes.

Corollary 9.

On comp(G𝒯S) there are at most 2𝒪(|S|2) 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

USV(G)dem(U)u|S| and USV(G)supl(U)u.

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 Ccomp(G𝒯S), we have sig(C)𝒱.

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 Ccomp(G𝒯S), we have |sig(C)||𝒱|2𝒪(|S|4) and we can compute sig(C) in running time 2𝒪(|S|4log|S|).

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 sig(𝒳). For all γsig(𝒳), we create a variable 𝐝𝒳,γ signifying how many components in 𝒳 use the configuration γ. We ensure for all 𝒳 that γsig(𝒳)𝐝𝒳,γ=|𝒳|. According to Corollaries 9 and 12, This uses 2𝒪(|S|4) 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 USV(G) a variable 𝐬U representing the final value of rU, amounting to at most 2|S| many additional variables. First, we ensure that 𝐬U is at most the difference between supply and demand for U. Second, let T𝒯, TWSV(G), and W be the set of minimally-connected hypergraphs on the vertex set W. We use for each HW a variable 𝐩T,H that signifies how often the hypergraph H is used to fulfill the demand of T. Using this, we can check that each hyper edge RSV(G) is used at most 𝐬R times overall while the demand of T is beeing fulfilled. We see that |W|2𝒪(|W|2); meaning, we only introduce 2𝒪(|S|2) additional variables.

To check Item 3 of Definition 7, assume that for all T𝒯S, i[d(T)], as well as USV(G), the variable 𝐚T,i,U corresponds to the binary indicator whether there is a Ccomp(G𝒯S), and j[|S|] with U=assignΓ(C)(T,i,j). If TSUSV(G), we create the binary variable 𝐛T,i,U. The variable 𝐛T,i,U is an indicator for whether U is the vertex set of the hypergraph H in Item 3 of Definition 7. So, we ensure that there is at most one TSZSV(G) with 𝐛T,i,Z=1 and that in any valid assignment Z=Ccomp(GS),j[|S|]assign(T,i,j). We ensure that H is connected using a cut based approach.

Overall, we need 2𝒪(|S|) variables of type 𝐚T,i,U and 𝐛T,i,U. This shows, that we can represent the instance as an ILP with 2𝒪(|S|4) 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 𝒫=(G,𝒯,d) be an instance of 𝖦𝖲𝖳𝖯. We can decide whether 𝒫 is a positive instance in running time 22𝒪(fn(G𝒯)4)|G|+𝒪(|𝒫|).

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 𝖶[1]-hard 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 w+1. 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.

(a) A graph family where the bags and links of the tree-cut decomposition are indicated in blue.
(b) The torso at m. The 3-center is the graph induced by zc1 and zc2.
Figure 1: A family of graphs with tree-cut width at most 5. In the depicted nice tree-cut decomposition the node m has +2 bold children, where can be chosen freely.
Corollary 14.

Any tree-cut decomposition (S,𝒳) can be altered in polynomial time to ensure that it becomes nice and for all sS, we have |b-chil(s)|+|Xs|w+2. 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 𝒟(S,𝒳) of G and let sV(S). Denote with cross(s){T𝒯TYsTYs} the set of terminal sets crossing the link between s and its parent. We call s simple if it is thin, |Ys|=1, adh(s)=2, and cross(s)=. 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 𝒟(S,𝒳) for G of width w. For all sV(S), the thin children of s mostly act like subdivided edges inside G[Xs]. To limit the number of trees that we need to consider crossing s, define dcross(s)Tcross(s)d(T).

Reduction Rule 16.

If there is a node sV(S) with dcross(s)>adh(s), output a trivial negative instance.

If we apply Reduction Rule 16, we can now choose for each sV(S) a function ηs:[dcross(s)]cross(s) such that for all Tcross(s) we have |ηs1(T)|=d(T). 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 [dcross(s)][w]. Based on this, we obtain a dynamic program for deciding the instance in 𝖥𝖯𝖳 time with respect to w.

The Data-Table.

The data-table D(s) at s, is a set of tuples τ, each consisting of three parts: pastPartτ, pastAssignτ, and futPartτ with pastAssignτ:pastPartτ[w]. Each of pastPartτ and futPartτ are partitions of a (not necessarily proper) subset of E(s). If pastPartτ and futPartτ are disjoint, we call τ syntactically valid. Note that we do not assign the partitions in futPartτ 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 s. Consider a solution (,π) to the whole instance and denote with the trees containing an edge of E(s). Set {Fπ(F)Ys} and as the subgraphs crossing the link between s and its parent, which are assigned to terminal set starting below this link and starting above this link, respectively. Let GsG[Ys]s be the graph edge-induced by all edges with at least one endpoint in Ys. This solution corresponds to a tuple τD(s) with pastPartτ{{E(K)E(s)Kcomp(F[E(Gs)])}}F and futPartτ{{E(K)E(s)Kcomp(F[E(Gs))])}}F where we consider the edges in E(s) per connected component of the trees in restricted to the edges incident to Ys. For each F, we choose a distinct λF[w] such that if π(F)cross(s), we have λF[dcross(s)] and ηs(λF)=π(F) and if π(F)cross(s), we have λF[w][dcross(s)]. Now, we set pastAssignτ to λF for each set induced by F.

Consider a syntactically valid tuple τ. To formally define what τD(s) is supposed to mean, let 𝒰s{T𝒯TYs}. Note that 𝒰s and cross(s) are disjoint and their union is the set of all terminals T𝒯 that are not disjoint from Ys. We add w vertices {qs,i}i[w] to Gs such that each has the neighborhood V(s)Ys. Call this graph Gs. These additional vertices can be used to simulate that a subgraph gets connected outside Gs. Let i[dcross(s)] and denote with Qs,i(ηs(i)Ys){qs,i} the vertices in Ys of the terminal set assigned to the i-th subgraph crossing s combined with qs,i. Additionally, define for each PfutPartτ the set Rs,PV(G[P])Ys to be all vertices of edges contained in P that are not in Ys. Finally, define the instance 𝒟s,τ(Gs,𝒰s{Qs,i}i[dcross(s)]{Rs,P}PfutPartτ,d), where for all T𝒰s we have d(T)=d(T), for all i[dcross(s)], we have d(Qs,i)=1, and for all PfutPartτ, we have d(Rs,P)=|{PfutPartτRs,P=Rs,P}|.

Definition 17.

For each sV(S) the data-table D(s) is the set of syntactically valid tuples τ at s where the instance 𝒟s,τ has a solution (,π) such that

  1. 1.

    we have E(s)E()pastPartτfutPartτ,

  2. 2.

    for all PfutPartτ and Fπ1(Rs,P), the set V(F) is disjoint from {qs,i}i[w],

  3. 3.

    for all PfutPartτ, there is a Fπ1(Rs,P) with E(F)E(S)=P,

  4. 4.

    for all i[w], let 𝒫ipastAssignτ1(i), then

    • if 𝒫i=, we have qs,iV(),

    • otherwise, there is exactly one F with qs,iV(F) and this F additionally satisfies that E(Fqs,i) can be partitioned into {EP}P𝒫i such that for all P𝒫i, the graph F[EP] is connected and EPE(s)=P.

With Item 1 we ensure that the edges used in the solution are accounted for in pastPartτ and futPartτ. We want to be able to assume that for every PfutPartτ there is a subgraph completely contained in Gs connecting all edges of P. So, in Item 2 we ensure that the vertices {qs,i}i[w] – that are used to simulate that a subgraph gets connected outside of this graph – are not included in the subgraphs connecting the edges in P. These subgraphs should also use exactly the edge-set P in E(s), which we ensure with Item 3. Finally, consider Item 4 and i[w]. If 𝒫i=, that is, no edges are assigned to the i-th subgraph, the vertex qs,i, which is used to mark the i-th subgraph crossing s, is not used in any subgraph. Otherwise, we again ensure that for each P𝒫i there is a subgraph in this solution that connects the edges of P inside Gs. Notice that we can combine Items 1, 3, and 4 to show, that for any F with E(F)E(s) there is a PpastPartτfutPartτ with PE(F).

Immediately, we observe that this dynamic program can indeed be used to determine whether 𝒫 is a positive instance, by checking for the root r of S whether D(r).

Computing the Data-Table.

To compute this dynamic program, we assume that for all bold children bb-chil(s) of s, we have already computed the data-table D(b). We now outline how to compute D(s) in 𝖥𝖯𝖳-time. As the number of syntactically valid tuples is in 2𝒪(wlogw), it is enough to decide in 𝖥𝖯𝖳-time for a given syntactically valid tuple τ whether τD(s). For this we iterate over all simultaneous choices of τbD(b) for bb-chil(s) and check whether the solutions witnessing τbD(b) can be extended to solutions witnessing τD(s).

Assume for all bb-chil(s) a τbD(b) is fixed. To combine the subgraphs of the sub-solutions witnessing τbD(b) to a solution witnessing τD(s), 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 Ss. 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 A{s}b-chil(s) and denote with 𝒯s{T𝒯TXs} the set of terminal sets completely contained in Xs, and with 𝒳𝒯saAcross(a) the set of all terminal sets, which are not completely contained in one sub-tree of Ss. Note that this claim holds for 𝒯s as none of their terminal vertices occur in any sub-tree of Ss. As 𝒟 is simple, s has at most w+2 bold children. So, w(w+3) is an upper bound on the total demand of all terminal sets crossing the links between s 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 s. So, we need at most w(w+3) 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 2𝒪(w3) 𝖦𝖲𝖳𝖯 instances with augmented fracture number at most 𝒪(w2) to decide whether this mapping gives a viable extension.

Theorem 18.

Given a simple tree-cut decomposition of width w, we can decide whether the instance is positive in time 22𝒪(w8)|V(G)|.

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 sV(S) and denote with Nst-chil(s) the set of thin and non-simple children of s. If for all s both |Ns| and |b-chil(s)|+|Xs|w 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 Δs|Ns|+|b-chil𝒟(s)|+|Xs|w1. We can compute in linear time an equivalent instance (G,𝒯,d) and a simple tree-cut decomposition 𝒞 of G with width

w+4+max(0,maxsV(S)Δs).

5.2 GSTP by Slim Tree-Cut Width

We now show that 𝖦𝖲𝖳𝖯 is 𝖥𝖯𝖳 by the slim tree-cut width of G. This is a direct application of Lemma 19. For this, denote with w¯w 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 sV(S) with adh(s)=1 and consider {uv}δ(Ys) with uYs and vYs. Remove uv from G and if there is a Tcross(s), increase the demand of (TYs){u} and (TYs){v} by 1 while removing T from 𝒯 (if necessary, add (TYs){u} and (TYs){v} 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 sV(S), we have |chil(s)|+|Xs|w¯. As Nst-chil(s), we have Δs|chil(s)|+|Xs|w1w¯w1. This allows us to apply Lemma 19 and obtain a simple tree-cut decomposition of width at most w¯+4. There is an algorithm that computes a tree-cut decomposition of slim width at most 6(stcw(G)+1)3 in time 2𝒪(stcw(G)2logstcw(G))|V(G)|4 [12]. Combined with Theorem 18, we obtain that 𝖦𝖲𝖳𝖯 is 𝖥𝖯𝖳 by the slim tree-cut width of the host graph.

Corollary 21.

Let 𝒫(G,𝒯,d) be an instance of 𝖦𝖲𝖳𝖯. We can decide whether 𝒫 is positive in time 22𝒪(stcw(G)24)poly(|𝒫|).

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 𝒟=(S,𝒳) is a tree-cut decomposition of G𝒯 with width w. Set XsXsV(G) and let 𝒳{Xs}sV(S) for all sV(S). Then, 𝒟(S,𝒳) is a tree-cut decomposition of G with width at most w. 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 sV(S){r} that are thin in 𝒟 that adh𝒟(s)=2 and cross𝒟(s)=. In particular, δG𝒯(Ys𝒟) 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 sV(S){r} that |Ys𝒟|1. We call nodes sV(S){r} that are thin in 𝒟, but have |Ys𝒟|2 cluttered. Second, we need to take care of all nodes that are bold in 𝒟, but thin in 𝒟. As 𝒟 is friendly, for each sV(S) 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 (G,𝒯,d) and a simple tree-cut decomposition 𝒞 of G of width at most w+5.

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 𝖶[1]-hard by the tree-cut width of the host-graph [13] lies in the fact, that for a cluttered node sV(S), we have for all T𝒯 that either TYs𝒟 or TYs𝒟 is empty. This means that no terminal set crosses Ys𝒟. Therefore, we can mostly disregard how the instance looks on V(G)Ys𝒟 for deciding how terminal sets contained in Ys𝒟 are solved in a solution of the whole instance. Let u,xYs and v,yV(G)Ys be such, that {uv,xy}=δG𝒯(Ys𝒟), and let 𝒰{T𝒯TYs} be the terminal sets contained in Ys𝒟. Note that uv,xyE(G). First, we consider the case, where we can satisfy the requirements of 𝒰, while supplying an additional connection for vy to V(G)Ys𝒟, while solving the requirements of 𝒰.

Reduction Rule 24.

Consider the instance 𝒳s(G[Ys𝒟],𝒰{u,x},d) where d is d|𝒰{u,x} increased by one for the argument {u,x}. If 𝒳s is positive, remove all 𝒰 from 𝒯 and contract Ys𝒟 in the original instance 𝒫.

If Reduction Rule 24 is not applicable, we know that we cannot use uv and xy in a tree for terminals contained in V(G)Ys𝒟. So, we check, whether the terminal sets 𝒰 can be solved only using edges of G[Ys𝒟].

Reduction Rule 25.

Assume that Reduction Rule 24 is not applicable to s. Consider the instance 𝒴s(G[Ys𝒟],𝒰,d|𝒰). If 𝒴s is positive, remove 𝒰 from 𝒯 and Ys𝒟 from G in the original instance 𝒫.

Finally, we need to take care of the case, where the terminal sets 𝒰 cannot be solved using only edges of G[Ys𝒟].

Reduction Rule 26.

Assume both Reduction Rules 24 and 25 are not applicable to s. Consider the instance 𝒵s(G/(V(G)Ys𝒟),𝒰,d|𝒰). If 𝒵s is positive, we remove 𝒰 from 𝒯, Ys𝒟 from G, and add 1 demand to the terminal set {v,y} in the remaining instance (if necessary, add {v,y} to 𝒯). Otherwise, output a trivial negative instance.

The tree-cut width of the augmented graphs of 𝒳s,𝒴s, and 𝒵s is at most w 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 sV(S) with |Ys𝒟|<|V(G)|2. 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 w+12. Now, we check recursively which of Reduction Rules 24, 25, and 26 is applicable. By choice of s, we can ensure that overall at most 𝒪(|V(G)|2) many simple instances are solved.

Theorem 27.

Assume 𝖦𝖲𝖳𝖯 can be solved in time r(g,k), given a graph of size at most g and a simple tree-cut decomposition of width at most k. Let 𝒫(G,𝒯,d) be an instance of 𝖦𝖲𝖳𝖯. Given a tree-cut decomposition of width w for G𝒯, we can decide whether 𝒫 is positive in time r(|G|,w+12)poly(|𝒫|).

Kim et al. [20] proved that for all graphs H we can compute a tree-cut decomposition of width 2tcw(H) in time 2𝒪(tcw(H)2logtcw(H))|V(H)|2. Combined with Theorem 18, we know that 𝖦𝖲𝖳𝖯 is FPT by the tree-cut width of the augmented graph.

Corollary 28.

Let 𝒫(G,𝒯,d) be an instance of 𝖦𝖲𝖳𝖯. We can decide whether this instance is positive in time 22𝒪(tcw(G𝒯)8)poly(|𝒫|).

6 STP by Tree-Cut Width

To show, how to decide an instance 𝒫(G,T,d) of 𝖲𝖳𝖯 parameterized by tcw(G), let 𝒟=(S,𝒳) be a friendly tree-cut decomposition of width w. If |T|w, we interpret 𝒫 as an instance of 𝖦𝖲𝖳𝖯. Consider the tree-cut decomposition 𝒟=(S,𝒳) for G{T}, obtained by adding a new root r containing aug(T) to S, and making the old root a child of r. The adhesion of 𝒟 is bounded by 2w. Let sV(S). Any tt-chil𝒟(s) with Yt𝒟T is also a thin child of s in 𝒟. Thus, |H~s𝒟|1+|T|+|b-chil(s)|+|Xs|2w+3. Note that the torso at r in 𝒟 consists of 2 vertices. Thus, the width of 𝒟 is bounded by 2w+3 and we can use Corollary 28 to decide whether the instance is positive in 𝖥𝖯𝖳-time.

(a) The host graph is a path of length n with 3 leaves attached to each vertex.
(b) The augmented graph, augmented edges and vertices are drawn in orange.
Figure 2: A family of instances where the tree-cut width of the augmented graph is unbounded.

The same approach does not work for the case |T|>w, 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 n 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 Ω(n4) [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., |T|>w), we observe that T is not contained in a single bag. By Reduction Rule 16, we can assume that d(T)w. As tw(G)=𝒪(w2), the parameter tw(G)+d(T) is bounded by a function of w. 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 (G,𝒯,d) be an instance of the 𝖦𝖲𝖳𝖯 problem and set ΣDT𝒯d(T). In time 2𝒪(ΣDtw(G)logtw(G))|V(G)|, 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 tw(G)+|T| [29].

Combined with the case distinction for 𝖲𝖳𝖯, that in time 2𝒪(tcw(G)2logtcw(G))|V(G)|2 we can find a tree-cut decomposition of width 2tcw(G) [20], and Corollary 28 we get that 𝖲𝖳𝖯 is 𝖥𝖯𝖳 by the parameter tcw(G).

Corollary 31.

Let (G,T,d) be an instance of 𝖲𝖳𝖯. In time 22𝒪(tcw(G)8)poly(|𝒢|), 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 |T|+d, 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 𝖶[1]-hard 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 𝖶[1]-hard parameterized by treewidth, even if |T|=3 [2, 1]. So, the only question remaining here is whether 𝖲𝖳𝖯 is 𝖥𝖯𝖳 parameterized by feedback vertex set number. As 𝖤𝖣𝖯 is 𝖶[1]-hard 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 𝖶[1]-hardness result for Integer 2-Commodity Flow parameterized by treewidth, which generalizes to 𝖲𝖳𝖯 with |T|=3 [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.