Parameterized single-exponential time polynomial space algorithm for Steiner Tree

In the Steiner tree problem, we are given as input a connected n-vertex graph with edge weights in {1, 2, . . . ,W}, and a subset of k terminal vertices. Our task is to compute a minimum-weight tree that contains all the terminals. We give an algorithm for this problem with running time O(7.97 ·n · logW ) using O(n · lognW · log k) space. This is the first single-exponential time, polynomial-space FPT algorithm for the weighted Steiner Tree problem.

Tree is known to be APX-complete, even when the graph is complete and all edge weights are either 1 or 2 [2].On the other hand, the problem admits a constant factor approximation algorithm, and the currently best such algorithm (after a long chain of improvements) is due to Byrka et al. and has approximation ratio ln 4 + \varepsi < 1.39 [6].
Steiner Tree is a fundamental problem in parameterized algorithms [7,8,10,19].The classic algorithm for Steiner Tree of Dreyfus and Wagner [9] from 1971 might well be the first parameterized algorithm for any problem.The study of parameterized algorithms for Steiner Tree has led to the design of important techniques, such as fast subset convolution [3] and the use of branching walks [18].Research on the parameterized complexity of Steiner Tree is still ongoing, with very recent significant advances for the planar version of the problem [20,21,17].
Algorithms for Steiner Tree are frequently used as a subroutine in fixedparameter tractable (FPT) algorithms for other problems; examples include vertex cover problems [15], near-perfect phylogenetic tree reconstruction [4], and connectivity augmentation problems [1].
Motivation and earlier work.For more than 30 years, the fastest FPT algorithm for Steiner Tree was the 3 k \cdot log W \cdot n \scrO (1) -time dynamic programming algorithm by Dreyfus and Wagner [9].Fuchs et al. [14] gave an improved algorithm with running time \scrO ((2 + \varepsi ) k n f (1/\varepsi ) log W ). For the unweighted version of the problem, Bj\" orklund et al. [3] gave a 2 k n \scrO (1) -time algorithm.All of these algorithms are based on dynamic programming and use exponential space.
Algorithms with high space complexity are in practice more constrained because the amount of memory is not easily scaled beyond hardware constraints, whereas time complexity can be alleviated by allowing for more time for the algorithm to finish.Furthermore, algorithms with low space complexity are typically easier to parallelize and more cache-friendly.These considerations motivate a quest for algorithms whose memory requirements scale polynomially in the size of the input, even if such algorithms may be slower than their exponential space counterparts.The first polynomial space 2 \scrO (k) n \scrO (1) -time algorithm for the unweighted Steiner Tree problem is due to Nederlof [18].This algorithm runs in time 2 k n \scrO (1) , matching the running time of the best known exponential space algorithm.Nederlof's algorithm can be extended to the weighted case; unfortunately this comes at the cost of an \scrO (W ) factor both in the time and the space complexity.Lokshtanov and Nederlof [16] showed that the \scrO (W ) factor can be removed from the space bound, but with a factor \scrO (W ) in the running time.The algorithm of Lokshtanov and Nederlof [16] runs in 2 k \cdot n \scrO (1) \cdot W time and uses n \scrO (1) log W space.Note that both the algorithm of Nederlof [18] and the algorithm of Lokshtanov and Nederlof [16] have an \scrO (W ) factor in their running time.Thus the running time of these algorithms depends exponentially on the input size, and therefore these algorithms are not FPT algorithms for weighted Steiner Tree.
For weighted Steiner Tree, the only known polynomial space FPT algorithm has a 2 \scrO (k log k) running time dependence on the parameter k.This algorithm follows from combining a (27/4) k \cdot n \scrO (log k) \cdot log W time, polynomial space algorithm by Fomin et al. [11] with the Dreyfus--Wagner algorithm.Indeed, one runs the algorithm of Fomin et al. [11] if n \leq 2 k , and the Dreyfus--Wagner algorithm if n > 2 k .If n \leq 2 k , the running time of the algorithm of Fomin et al. is bounded from above by 2 \scrO (k log k) .When n > 2 k , the Dreyfus--Wagner algorithm becomes a polynomial time (and space) Prior to this work, the existence of a polynomial space algorithm with running time 2 \scrO (k) \cdot n \scrO (1) \cdot log W , i.e., a single-exponential time polynomial space FPT algorithm, was an open problem asked explicitly in [11,16].
Contributions and methodology.The starting point of our present algorithm is the (27/4) k \cdot n \scrO (log k) \cdot log W time, polynomial-space algorithm by Fomin et al. [11].This algorithm crucially exploits the possibility for balanced separation (cf.Lemma 2.1).Specifically, an optimal Steiner tree ST can be partitioned into two trees ST 1 and ST 2 containing the terminal sets T 1 and T 2 , respectively, so that the following three properties are satisfied: (1) The two trees share exactly one vertex v and no edges.
(2) Neither of the two trees ST 1 or ST 2 contains more than a 2/3 fraction of the terminal set T .(3) The tree ST 1 is an optimal Steiner tree for the terminal set T 1 \cup \{ v\} , and ST 2 is an optimal Steiner tree for the terminal set T 2 \cup \{ v\} .Conversely, to find the optimal tree ST for the terminal set T , it suffices to (1) guess the vertex v, (2) partition T into T 1 and T 2 , and (3) recursively find optimal trees for the terminal sets T 1 \cup \{ v\} and T 2 \cup \{ v\} .The most unbalanced partition (T 1 , T 2 ) of T in ( 2 Unraveling (1) gives the (27/4) k \cdot n \scrO (log k) \cdot log W upper bound for the running time, and it is easy to see that the algorithm runs in polynomial space.However, this algorithm is not an FPT algorithm because of the n \scrO (log k) factor in the running time.
The factor n \scrO (log k) is incurred by the factor n in (1), which in turn originates from the need to iterate over all possible choices for the vertex v in each recursive call.In effect the recursion tracks an \scrO (log k)-sized set S of split vertices (together with a subset T \prime of the terminal vertices T ) when it traverses the recursion tree from the root to a leaf.
The key idea in our new algorithm is to redesign the recurrence for optimal Steiner trees so that we obtain control over the size of S using an alternation between 1. balanced separation steps (as described above) and 2. novel resplitting steps that maintain the size of S at no more than three vertices throughout the recurrence.In essence, a resplit takes a set S of size 3 and splits that set into three sets of size 2 by combining each element in S with an arbitrary vertex v, while at the same time splitting the terminal set T \prime into three parts in all possible (not only balanced) ways.While the combinatorial intuition for resplitting is elementary (cf.Lemma 2.2 below), the implementation and analysis requires a somewhat careful combination of ingredients.
Namely, to run in polynomial space, it is not possible to use extensive amounts of memory to store intermediate results to avoid recomputation.Yet, if no memorization is used, the novel recurrence does not lead to an FPT algorithm, let alone to a singleexponential FPT algorithm.Thus neither a purely dynamic programming nor a purely recursive implementation will lead to the desired algorithm.A combination of the two Roughly, our approach is to employ recursive evaluation over subsets T \prime of the terminal set T , but each recursive call with T \prime will compute and return the optimal solutions for every possible set S of split vertices.Since by resplitting we have arranged that S always has size at most 3, this hybrid evaluation approach will use polynomial space.Since each recursive call on T \prime yields the optimum weights for every possible S, we can use dynamic programming to efficiently combine these weights so that single-exponential running time results.
In precise terms, our main result is as follows.
Whereas our main result seeks to optimize the polynomial dependency in n for both the running time and space usage, it is possible to trade between polynomial dependency in n and the single-exponential dependency in k to obtain faster running time as a function of k, but at the cost of increased running time and space usage as a function of n.In particular, we can use larger (but still constant-size) sets S to avoid recomputation and to arrive at a somewhat faster algorithm.
Theorem 2. There exists a polynomial-space algorithm for Steiner Tree running in \scrO (6.751 k n \scrO (1) log W ) time.
Finally, by using more ideas, like introducing even balanced separators of larger cardinality in trees and generalizing our Steiner Tree algorithm on Subset Steiner Forest, we obtain the following theorem.
Theorem 3.For any \epsilon > 0 there is an n \scrO (f (\epsilon )) log W space 4 (1+\epsilon )k n \scrO (f (\epsilon )) log W time algorithm for Steiner Tree, where f is a computable function depending only on \epsilon .
Notice that to get polynomial space parameterized single-exponential time algorithms for the unweighted version of Steiner Tree, it is enough to substitute uniform weight to all of the edges (for example, the weight of each edge is 2) in the above theorems.

Preliminaries.
Given a graph G, we write V (G) and E(G) for the set of vertices and edges of G, respectively.For subgraphs G 1 , G 2 of G, we write G 1 + G 2 for the subgraph of G with vertex set V (G 1 ) \cup V (G 2 ) and edge set E(G 1 ) \cup E(G 2 ).For a graph G, S \subsete V (G) and v \in V (G), we use G -S and G -v to denote the induced subgraphs G[V (G) \setminu S] and G[V (G) \setminu \{ v\} ], respectively.The minimum weight of a Steiner tree of G on terminals T is denoted by st G (T ).When graph G is clear from the context, we will simply write st(T ).For a set U and a nonnegative integer i, we use \bigl( U i \bigr) and \bigl( U \leq i \bigr) to denote the set of all subsets of U of size exactly i and the set of all subsets of U of size at most i, respectively.
Partitions.A partition of a nonempty set U is a collection of nonempty, pairwise disjoint subsets of U whose union is U .The subsets are called blocks.For a set U , we write U 1 \uplus U 2 \uplus \cdot \cdot \cdot \uplus U \ell = U if U 1 , U 2 , . . ., U \ell is a partition of U .For a set U and a positive integer i, we use P(U ) and P i (U ) to denote the set of all partitions of U and the set of all partitions of U into i blocks, respectively.For convenience we use P(\emptyse ) = \{ \emptyse \} .For a set U and a constant \epsilon \geq 0, we use \scrB \epsilon (U ) to denote the set of all partitions (U 1 , U from the blocks of P .For a set U and partitions P 1 , P 2 \in P(U ), we say partition P 1 refines partition P 2 , denoted by P 1 \preceq P 2 , if every block of P 1 is contained in some block of P 2 .We also use P 1 \preceq P 2 if P 1 is a restriction of a partition in P(U ) which refines partition P 2 .That is, for a set U , a subset U \prime of U , and partitions P 1 \in P(U \prime ) and P 2 \in P(U ), we write P 1 \preceq P 2 if each block of P 1 is contained in some block of P 2 .For two partitions P 1 and P 2 in P(U ), the join of P 1 and P 2 , denoted by P 1 \sqcup P 2 , is the smallest (with respect to \preceq ) partition P refined by both P 1 and P 2 .For a graph G, we use Separation and resplitting.A set of nodes S is called an \alpha -separator of a graph G, 0 < \alpha \leq 1, if the vertex set V (G) \setminu S can be partitioned into sets V L and V R of size at most \alpha n each, such that no vertex of V L is adjacent to any vertex of V R .We next define a similar notion, which turns out to be useful for Steiner trees.Given a Steiner tree ST on terminals T , an \alpha -Steiner separator S of ST is a subset of nodes which partitions ST -S into two forests \scrR 1 and \scrR 2 , each one containing at most \alpha k terminals from T .Lemma 2.1 (separation).(See [5,11].)Every Steiner tree ST on terminal set T , | T | \geq 3, has a 2/3-Steiner separator S = \{ s\} of size one.
The following easy lemma enables us to control the size of the split set at no more than three vertices.Lemma 2.2 (resplitting).Let F be a tree and S \in \bigl( V (F )

\bigr)
. Then there is a vertex v \in V (F ) such that each connected component in F -v contains at most one vertex of S.
Proof.Let S = \{ s 1 , s 2 , s 3 \} .Let P 1 be the unique path between s 1 and s 3 in the tree F .Let P 2 be the unique path between s 3 and s 2 in the tree F .If P 1 and P 2 are edge-disjoint, then V (P 1 ) \cap V (P 2 ) = \{ s 3 \} and P 1 P 2 is the unique path between s 1 and s 2 .Thus any connected component in G -s 3 will not contain both s 1 and s 2 .In this case s 3 is the required vertex.Suppose V (P 1 ) \cap V (P 2 ) \not = \{ s 3 \} .For a path P = u 1 u 2 . . .u \ell in a graph G, let \leftarr -P denote the reverse path u \ell u \ell - 1 . . .u 1 .Consider the unique path \leftarr -P 1 between s 3 and s 1 , which is the reverse of the path P 1 .Since F is a tree, these paths \leftarr -P 1 and P 2 will be of the form P 1 = Q \leftarr -P 1 \prime and P 2 = QP \prime 2 .Note that Q is a path starting at s 3 .Let w be the last vertex in the path Q.Since F is a tree, V ( \leftarr -P 1 \prime ) \cap V (P \prime 2 ) = \{ w\} .Now consider the graph G -w. Any connected component in G -w will not contain more than one vertex from \{ s 1 , s 2 , s 3 \} , because the unique path between any pair of vertices in \{ s 1 , s 2 , s 3 \} passes through w.

Algorithm.
In this section, we design an algorithm for Steiner Tree which runs in \scrO (7.97 k n 4 log(nW )) time using \scrO (n 3 log(nW ) log k) space.Most algorithms for Steiner Tree, including ours, are based on recurrence relations that reduce finding an optimal Steiner tree to finding optimal Steiner trees in the same graph, but with a smaller terminal set.We first define two functions f i for i \in \{ 2, 3\} .Each function f i , i \in \{ 2, 3\} takes as input a vertex set S of size at most i (the split set defined in the introduction) and a subset T \prime of T .The function f i (S, T \prime ) returns a real number.We will define the functions using recurrence relations, and then prove that f i (S, T \prime ) is exactly st G (T \prime \cup S).These two functions are alternatively invoked by our algorithm.Later we define two more functions f i for i \in \{ 0, 1\} , and they are invoked only in the first two recursive steps of our algorithm.
The recurrences ( 2) and ( 3) are recurrence relations for Steiner Tree as proved in the following lemma.Lemma 3.1.For all T \prime \subsete T , i \in \{ 2, 3\} , and S \in \bigl( V (G) Proof.We prove the lemma using induction on | T \prime | .For the base case | T \prime | \leq 2, the lemma holds by the definition of f i .For the inductive step, let us assume that the lemma holds for all T \prime \prime of size less than j.We proceed to show that f i (S, T \prime ) = st G (T \prime \cup S) for all T \prime \subsete T with | T \prime | = j.We split into cases based on i and in each case establish the inequalities f i (S, T \prime ) \leq st G (T \prime \cup S) and f i (S, T \prime ) \geq st G (T \prime \cup S) to conclude equality.
Conversely, let ST be an optimum Steiner tree for the set of terminals T \prime \cup S. Thus ST is also a Steiner tree for the set of terminals T \prime .Hence by Lemma 2.
We would like to mention that 3 is the smallest size of S for which we can do resplitting and reduce the size of the separator (i.e., first argument in the function f i ).Our algorithm uses (2) and (3) repeatedly to compute the weight of an optimum Steiner tree.Notice that f 2 (\emptyse , T ) is equal to the weight of an optimum Steiner tree.Since f 3 runs over all partitions of size 3, unlike the balanced partitions in the case of f 2 , f 3 is costlier for the running time of the algorithm.Also notice that f 2 (\emptyse , T ) invokes two instances of f 3 with the first argument being size one sets in each instance.In fact for those two instances of f 3 , we do not have to make a resplitting step.Thus towards designing a faster algorithm we define two more functions f 0 and f 1 which are defined similarly to f 2 .For T \prime \subsete T , i \in \{ 0, 1\} , and S \in \bigl( V (G) , we define f i (S, T \prime ) as follows.When | T \prime | \leq 2, we set f i (S, T \prime ) = st G (T \prime \cup S).For | T \prime | \geq 3, we define f i (S, T \prime ) using the following recurrence: Lemma 3.2.For all T \prime \subsete T , i \in \{ 0, 1\} , and S \in \bigl( V (G) Proof.By substituting i = 1 in Case 1 of the proof of Lemma 3.1 and the fact that f 2 (S 1 \cup \{ v\} , T 1 ) = st G (T 1 \cup S 1 \cup \{ v\} ) and f 2 (S 2 \cup \{ v\} , T 2 ) = st G (T 2 \cup S 2 \cup \{ v\} ) (by Lemma 3.1), we conclude that f 1 (S, T \prime ) = st G (T \prime \cup S).Again, by arguments similar to that of the proof for the case i = 1, we conclude that f 0 (S, T \prime ) = st G (T \prime \cup S).
A na\" {\i} ve way of turning the recurrences into an algorithm would be to simply make one recursive procedure for each f i , and apply (4), (2), and (3) directly.However, this would result in a factor n \scrO (log k) in the running time, which we seek to avoid.The reason to get a factor n \scrO (log k) in the running time of a na\" {\i} ve implementation is the number of branches of each node in the recurrence tree is at least n \scrO (1) (because the number of choices of separators for each recurrence is n \scrO (1) ) and the depth of the recurrence tree is \scrO (log k) (because of the balanced partition in (2)).Like the na\" {\i} ve approach, our algorithm has one recursive procedure F i for each function f i .The procedure F i takes as input a subset T \prime of the terminal set, and returns an array that, for every S \in \bigl( V (G) , contains f i (S, T \prime ).The key observation is that if we seek to compute f i (S, T \prime ) for a fixed T \prime and all choices of S \in \bigl( V (G) \leq i \bigr) using recurrence (4) or ( 2 every choice of S and then apply the recurrence to compute f i (S, T \prime ); it is much faster to compute all of the entries of the return array of F i simultaneously, by iterating over every eligible partition of T \prime , making the required calls to F i+1 (or F i - 1 if we are using recurrence (3)), and updating the appropriate array entries to yield the return array of F i .Next, we give pseudocode for the procedures F 0 , F 1 , F 2 , F 3 .The procedure F i for 0 \leq i \leq 2 operates as follows.(See Algorithm 1.) Let T \prime \subsete T be the input to the procedure F i .If | T \prime | \leq 2, then F i computes st G (T \prime \cup S) for all S \in \bigl( V (G) \leq i \bigr) using the Dreyfus--Wagner algorithm and returns these values.The procedure F i has an array A indexed by S \in \bigl( V (G) \leq i

\bigr)
. At the end of the procedure F i , A[S] will contain the value st G (T \prime \cup S) for each S \in \bigl( V (G) \leq i \bigr) . For each (T 1 , T 2 ) \in \scrB 1/6 (T \prime ) (line 10), F i calls F i+1 (T 1 ) and F i+1 (T 2 ) and it returns two sets of values \bigr) \} , respectively.Let A 1 and A 2 be two arrays used to store the return values of F i+1 (T 1 ) and \bigr) . Now we update A as follows.For each S 1 \uplus S 2 \in \bigl( V (G)  .For each (T 1 , T 2 , T 3 ) \in P 3 (T \prime ) (line 10), F 3 calls F 2 (T 1 ), F 2 (T 2 ), and F 2 (T 3 ), and it returns three sets of values \bigr) \} , respectively.Let A 1 , A 2 , and A 3 be three arrays used to store the outputs of F 2 (T 1 ), F 2 (T 2 ), and F 2 (T 3 ), respectively.That is, A r [S] = f 2 (S, T r ) for r \in \{ 1, 2, 3\} .Now we update A as follows.For each S 1 , S 2 , S 3 \in \bigl( V (G) In what follows, we prove the correctness and analyze the running time and memory usage of the call to the procedure F 0 (T ).Lemma 3.3.For every i \leq 3, and every set T \prime \subsete T , the procedure F i (T \prime ) outputs an array that contains f i (S, T \prime ) for every S \in \bigl( V (G) \leq i \bigr) .
Proof.Correctness of the lemma follows directly by an induction on | T | .Indeed, assuming that the lemma statement holds for the recursive calls made by the procedure F i , it is easy to see that each entry of the output table is exactly equal to the righthand side of recurrence ( 4) or (2) (recurrence (3) in the case of F 3 ).
Observation 3.1.The recursion tree of the procedure F 0 (T ) has depth \scrO (log k).
Proof.For every i \leq 2 the procedure F i (T \prime ) only makes recursive calls to F i+1 (T \prime \prime ) where | T \prime \prime | \leq 2| T \prime | /3.The procedure F 3 (T \prime ) makes recursive calls to F 2 (T \prime \prime ) where | T \prime \prime | \leq | T \prime | .Therefore, on any root-leaf path in the recursion tree, the size of the considered terminal set T \prime drops by a constant factor every second step.When the terminal set reaches size at most 2, no further recursive calls are made.Thus any root-leaf path has length at most \scrO (log k).
Lemma 3.4.The procedure F 0 (T ) uses \scrO (n 3 log(nW ) log k) space.Proof.As each F i , i \in \{ 0, 1, 2, 3\} , is a recursive procedure once its recursive call is returned, the memory used by the recursive procedure can be reused.Thus to upper bound the space used by the procedure F 0 (T ), it is sufficient to upper bound the memory usage of every individual recursive call, not taking into account the memory used by its recursive calls, and then multiply this upper bound by the depth of the recursion tree.
Each individual recursive call will at any point of time keep a constant number of tables, each containing at most \scrO (n 3 ) entries.Each entry is a number less than or equal to nW ; therefore, each entry can be represented using at most \scrO (log(nW )) bits.Thus each individual recursive call uses at most \scrO (n 3 log(nW )) bits.Combining this with Observation 3.1 proves the lemma.
Next, we analyze the running time of the algorithm.On an n-vertex graph, let \tau i (k) be the total number of arithmetic operations of the procedure F i (T \prime ) for all i \leq 3, where k = | T \prime | .It follows directly from the structure of the procedures F i for i \leq 2, that there exists a constant C such that the following recurrence holds for \tau i , i \leq 2: In the above expression, the term Cn 3 is the time required to execute the inner for loop of \bigr) be the number of partitions of k distinct elements into sets of sizes i 1 , i 2 , and i 3 such that i 1 + i 2 + i 3 = k.It follows directly from the structure of the procedure F 3 that there exists a constant C such that the following recurrence holds for \tau 3 : In the above expression, the term Cn 4 is the time required to execute the inner for loop of F 3 .Now we will bound \tau 3 (k) from above using ( 5) and ( 6).The following facts are required for the proof.
Fact 2. For every fixed x \geq 4, the function f (y) = Proof.We prove by induction on k that \tau 2 (k) \leq \Ĉ k (c log k) 9.78977 k n 4 and \tau 3 (k) \leq \ Ck (c log k) 11.7898 k n 4 , where \Ĉ and c are constants.We will select the constant \Ĉ to be larger than the constants of ( 5) and ( 6), and sufficiently large so that the base case of the induction holds.We prove the inductive step.By the induction hypothesis and (5), we have that \tau 2 (k) \leq 2k max  The last inequality holds for a sufficiently large C i depending on C i+1 and \beta i+1 but not on k.
We are now in position to prove our main theorem.Proof of Theorem 1.The algorithm calls the procedure F 0 (T ) and returns the value stored for f 0 (\emptyse , T ).By Lemma 3.3, the procedure F 0 (T ) correctly computes f 0 (\emptyse , T ), and by Lemma 3.1, this is exactly equal to the weight of an optimal Steiner tree.By Lemma 3.4, the space used by the algorithm is at most \scrO (n 3 log(nW ) log k), and by Lemma 3.7, the time used is \scrO (7.97 k n 4 log(nW )).

3.1.
Obtaining better parameter dependence.The algorithm from Theorem 1 is based on defining and computing the functions f i , 0 \leq i \leq 3. The functions f i , i \leq 2, are defined using recurrence (2), while the function f 3 is defined using recurrence (3).For every constant t \geq 4, we could obtain an algorithm for Steiner Tree by defining functions f i , 0 \leq i \leq t -1, using (2) and f t using (3).A proof identical to that of Lemma 3.1 shows that f i (S, T \prime ) = ST G (S \cup T \prime ) for every i \leq t.
We can now compute f 0 (\emptyse , T ) using an algorithm almost identical to the algorithm of 1, except that now we have t + 1 procedures, namely a procedure F i for each i \leq t.For each i and terminal set T \prime \subsete T , a call to the procedure F i (T \prime ) computes an array containing f i (S, T \prime ) for every set S of size at most i.
For i < t, the procedure F i is based on (2) and is essentially the same as Algorithm 1. Further, the procedure F t is based on (3) and is essentially the same as Algorithm 2. The correctness of the algorithm and an \scrO (n t log(nW )) upper bound on the space usage follow from arguments identical to Lemmas 3.3 and 3.4, respectively.
For the running time bound, an argument identical to Lemma 3.5 shows that \tau t (k) = \scrO (11.7899 k n t+1 ).Furthermore, Lemma 3.6 now holds for i \leq t -1.In the proof of Lemma 3.7, the bound for \tau 0 (k) is obtained by starting with the \scrO (11.7899 k n 4 ) bound for \tau 3 and applying Lemma 3.6 three times.Here we can upper bound \tau 0 (k) by starting with the \scrO (11.7899 k n t+1 ) bound for \tau t and applying Lemma 3.6 t times.This yields a C 0 \cdot \beta k 0 upper bound for \tau 0 (k), where \beta 0 = (11.7899 (2/3) t )1.8899 It is easy to see that when t \geq 25 the upper bound for \beta 0 is a number between 6.75 and 6.751.This proves Theorem 2.
4. Faster polynomial space algorithm.In this section, for any \epsilon > 0, we design a 4 (1+\epsilon )k n \scrO (f (\epsilon )) log W time, n \scrO (f \prime (\epsilon )) log W space algorithm for Steiner Tree, where f and f \prime are computable functions that depend only on \epsilon .Towards that we need to explain Subset Steiner Forest problem and show that the algorithm in section 3 can be generalized to an algorithm for Subset Steiner Forest.In subsection 4.1 we explain Subset Steiner Forest.Then in subsection 4.2 we give a faster polynomial space algorithm for Steiner Tree.Then by induction hypothesis g (c) (S \prime , P 1 , T 1 ) = sf G (P 1 , T 1 ) and g (c) (S \prime , P 2 , T 2 ) = sf G (P 2 , T 2 ).So we have that g (c) (S, P S , T ) = sf G (P 1 , T 1 ) + sf G (P 2 , T 2 ).Let SF 1 and SF 2 be optimum subset Steiner forests for the pairs (P 1 , T 1 ) and (P 2 , T 2 ), respectively.Hence, by Lemma 4.3, G \prime = SF 1 + SF 2 is a subset Steiner forest for the pair (P S , T ).Thus we have shown that G \prime is a subset Steiner forest for the pair (P S , T ) of weight g (c) (S, P S , T ).This implies that g (c) (S, P S , T ) \geq sf G (P S , T ).
Conversely, let SF be an optimum subset Steiner forest for the pair (P S , T ).By Lemma 4.2 we know that there exists an ( 12 + \alpha )-Steiner separator S \prime \prime of SF such that | S \prime \prime | \leq c.Let S \prime = S \prime \prime \cup S. Since S \prime \supsete S \prime \prime , S \prime is also an ( 2 +\alpha )| T | for any r \in \{ 0, 1\} .Note that (T 1 , T 2 ) \in \scrB \alpha (T ).Since S \prime is a separator for \scrR 1 and \scrR 2 in SF , there is no edge in E(SF ) which is incident to both \scrR 1 and \scrR 2 .Let E 1 be the set of edges in E(SF ) which are incident to \scrR 1 , and let E 2 = E(SF ) \setminu E 1 .Consider the graphs F 1 = (V (\scrR 1 ) \cup S \prime , E 1 ) and F 2 = (V (\scrR 2 ) \cup S \prime , E 2 ).The graphs F 1 and F 2 are subset Steiner forests for the pairs (P F1 [S \prime ], T 1 ) and (P F2 [S \prime ], T 2 ), respectively (recall that for a graph G, P G is the partition of V (G), where each block is the vertex set of a component in G).Thus we have that w(SF ) = w(F 1 ) + w(F 2 ) \geq sf G (P F1 [S \prime ], T 1 ) + sf G (P F2 [S \prime ], T 2 ).(10) Since F 1 + F 2 = SF , we have that P S \preceq P F1 [S \prime ] \sqcup P F2 [S \prime ].Thus, we have that | S \prime \setminu S| \leq c, (T 1 , T 2 ) \in \scrB \alpha (T ), and P F1 [S \prime ], P F2 [S \prime ] \in P(S \prime ) such that P S \preceq P F1 [S \prime ] \sqcup P F2 [S \prime ].Hence by induction hypothesis and our recurrence relation (9), we have that sf G (P F1 [S \prime ], T 1 ) + sf G (P F2 [S \prime ], T 2 ) \geq g (c) (S, P S , T ).Combining this with (10), we get g (c) (S, P S , T ) \leq w(SF ) = sf G (P S , T ).Now for any \epsilon > 0, we explain an n \scrO (f \prime (\epsilon )) log W space 4 (1+\epsilon )k n \scrO (f (\epsilon )) log W time algorithm for Steiner Tree.We fix (later) two constants c \geq 4 and d based on \epsilon .Let \alpha = 1 2 (c/2) and \beta = \bigl( 1 2 + \alpha \bigr) d .The algorithm is a recursive algorithm based on (9).Whenever the cardinality of the terminal set in a recursive call is bounded by \beta k, the algorithm uses 4 as a black box.Otherwise, it branches according to (9).The initial call to the recurrence is on the set of terminals T , S = \emptyse , and P S = \emptyse .Since each application of (9) reduces the cardinality of the terminal set by a factor of ( 1 2 + \alpha ), the depth of the recurrence tree is bounded by d.Hence the total number of vertices in the partition when our algorithm invokes Theorem 4 is bounded by d \cdot c.This implies that the space usage of our algorithm is bounded by (n dc(dc+1) + d) log W . Now we bound the running time of the algorithm.Let T (k) be the running time of the algorithm for an n-vertex graph.

c
\bigcirc 2019 SIAM.Published by SIAM under the terms of the Creative Commons 4.0 license Downloaded 04/18/19 to 130.233.216.81.Redistribution subject to CCBY license overview of the results and applications of the Steiner Tree problem.Steiner
) has one block containing 1/3 fraction of T and another block containing 2/3 fraction of T .Since there are n choices for v, and \bigl( k k/3 \bigr) ways to partition T into two sets T 1 and T 2 such that | T 1 | = | T | /3, the running time of the algorithm is essentially governed by the recurrence (1)

4. 1 .
Subset Steiner forest.In this subsection we generalize our parameterized single-exponential time polynomial space algorithm (the algorithm in section 3) to a general version of the Steiner Tree problem, named Subset Steiner Forest.Definition 4.1.Let G be a graph, w : E(G) \rightar \{ 1, 2, . . ., W \} be a nonnegative weight function, \scrS be a partition of a subset of vertices, and T \subsete V (G) be a set of terminals.A subgraph G \prime of G is called a subset Steiner forest of G on the partition \scrS and the terminal set T if the following conditions hold: \bullet T \cup \bigl( \bigcup S\in \scrS S \bigr) \subsete V (G \prime ), \bullet for all S \in \scrS , there is a connected component C in G \prime such that S \subsete V (C), and \bullet for any t \in T , the connected component C in G \prime , containing t, also contains some S \in \scrS .c \bigcirc 2019 SIAM.Published by SIAM under the terms of the Creative Commons 4.0 license Downloaded 04/18/19 to 130.233.216.81.Redistribution subject to CCBY license Since (T 1 , T 2 ) \in \scrB \alpha (T ) and | T | \geq 2, we have that | T 1 | , | T 2 | < | T | .

Lemma 4 . 5 .c
There exists a constant C such that for any k \prime \leq k,T (k \prime ) = C \cdot (dc) (2dc)d \prime n cd \prime n cd(cd+4) 2 d \prime log nW \cdot (7.97) \beta k 4 k \prime 2Let C be a constant such that the algorithm in Theorem 4 runs in time C \cdot 7.97 k n r(c+4) log(nW ).We prove the lemma by induction on k \prime .Assume that the lemma holds for all values of k \prime < k.Now we need to bound T (k).According to(9),T (k) = n c c 2c2 k \cdot 2 \cdot T \biggl( \biggl( \bigcirc 2019 SIAM.Published by SIAM under the terms of the Creative Commons 4.0 license Downloaded 04/18/19 to 130.233.216.81.Redistribution subject to CCBY license Downloaded 04/18/19 to 130.233.216.81.Redistribution subject to CCBY license will, however, give a single-exponential time algorithm that uses polynomial space.
The last inequality holds if c is a sufficiently large constant (independent of k).By c \bigcirc 2019 SIAM.Published by SIAM under the terms of the Creative Commons 4.0 license Downloaded 04/18/19 to 130.233.216.81.Redistribution subject to CCBY license The last inequality holds for sufficiently large constants \Ĉ and c.For a sufficiently large constant C it holds that C \cdot 11.7899 k n 4 \geq 11.7898 k \cdot \Ĉ k (c log k) n 4 , completing the proof.To upper bound \tau 0 (k) from \tau 3 (k), we repeatedly use the following lemma.Lemma 3.6.For every i \leq 2 and constants C i+1 and \beta i+1 \geq 4 such that for every k \geq 1 we have \tau i+1 (k) \leq C i+1 \beta k i+1 n 4 , there exists a constant C i such that \tau i (k) \leq C i \cdot 1.8899 k \cdot \beta