Online Steiner Forest with Recourse
Abstract
In the online Steiner forest problem we are given a graph , and a sequence of terminal pairs which arrive in an online fashion. We are asked to maintain a low-cost subgraph in which each is connected to for all the pairs that have arrived so far. If we are not allowed to delete edges from our solution, then the best possible competitive ratio is . In this work, we initiate the study of low-recourse algorithms for online Steiner forest. We give an algorithm that maintains a constant-competitive solution and has an amortized recourse of , i.e., inserts and deletes edges per demand on average.
Keywords and phrases:
Online algorithms with recourse, Steiner forest, Network designCategory:
Track A: Algorithms, Complexity and GamesCopyright and License:
2012 ACM Subject Classification:
Theory of computation Online algorithmsAcknowledgements:
The authors want to thank Roie Levin and Anupam Gupta for helpful discussions.Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele PuppisSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
The Steiner tree problem is a classic question in network design. Given a weighted graph and a subset of vertices called terminals, it asks to compute the cheapest tree that connects the terminals. Since being included on Karp’s list of 21 NP-complete problems [61] it has been extensively studied. The problem is known to be APX-hard [37]; however, getting a constant-factor approximation is straightforward, as computing a minimum spanning tree on the set of terminals already yields a 2-approximation [62]. The current best approximation guarantee is [31].
In the online version of the Steiner tree problem, introduced in a seminal work of Imase and Waxman [59], the terminals arrive online, and after each arrival the algorithm must produce a solution that connects the current terminal set – without knowledge of the future arrivals and without the possibility of deleting already added edges. They showed that the natural greedy algorithm is -competitive, and that no algorithm can obtain a better competitive ratio.
Motivated by this impossibility result, Imase and Waxman [59] also asked the question of whether deleting a small number of edges would allow one to maintain a constant-competitive solution. They showed how to maintain such a Steiner tree while making changes per arrivals (which improves upon the changes needed if one naively recomputes the tree after each arrival). In other words, they gave a constant-competitive algorithm with amortized recourse. This was eventually improved over 20 years later by Megow, Skutella, Verschae, and Wiese [68] to constant amortized recourse. Finally, Gu, Gupta, and Kumar [50] showed that it is in fact enough to make just a single edge swap per arrival.
In the more general Steiner forest problem, instead of a set of terminals we are given a set of terminal pairs, and asked to compute the cheapest forest that connects the vertices of each terminal pair together. The first (offline) approximation algorithm for the problem is a primal-dual approach by Agrawal, Klein, and Ravi [2] that yields a -approximation; this was further generalized by Goemans and Williamson [47], and the approximation ratio was improved only very recently to [3] and subsequently to 1.994 [58]. As for algorithms based on more combinational techniques, a natural greedy algorithm that repeatedly connects the closest yet-unconnected terminal pair is no better than [36], but Gupta and Kumar [55] showed that the gluttonous algorithm, which repeatedly connects the two closest terminals (possibly not from the same pair), does yield a constant-factor approximation. Furthermore, Groß, Gupta, Kumar, Matuschke, Schmidt, Schmidt, and Verschae [48] gave a constant-factor approximation based on local search.
The focus of this work is the online version of the Steiner forest problem, introduced by Westbrook and Yan [79], who gave an -competitive algorithm. Next, Awerbuch, Azar, and Bartal [8] showed that the greedy algorithm is -competitive using a primal-dual analysis. Finally, Berman and Coulston [14] gave a primal-dual -competitive algorithm. (This is optimal due to the abovementioned hardness result for online Steiner tree [59]. Their algorithm is not greedy; the competitive ratio of greedy is a prominent open problem, see e.g. [10].)
In contrast to Steiner tree, for Steiner forest no -competitive, low-recourse algorithm has been known. Finding such an algorithm has been listed as “an interesting open problem” in [54] and “still wide open” in [48].
1.1 Our Results
In this work we give the first low-recourse constant-competitive algorithm for online Steiner forest.
Theorem 1.
There is an algorithm for online Steiner forest that, over the course of arrivals of terminal pairs in a metric space, maintains an -competitive solution while inserting and deleting at most edges.
Our approach in fact yields a tradeoff: for any parameter , it achieves competitive ratio and total recourse . See Theorem 8 for a detailed version of Theorem 1.
Remark 2.
As a byproduct of our approach, we also get an -competitive algorithm for the online Steiner forest problem (the classic, no-recourse setting). At a high level, this follows by neglecting to delete the edges that our algorithm decides to delete, and roughly corresponds to simulating the gluttonous algorithm in an online fashion (see Appendix A for a formal algorithm description). This matches the optimal guarantee of Berman and Coulston [14] using a fully combinatorial algorithm as opposed to their primal-dual one.
1.2 Related Work
Online algorithms with low recourse (often called consistent) are a very active and growing research area. Such algorithms have been proposed for many problems: clustering and facility location [66, 51, 38, 43, 22, 64, 44, 34, 28], scheduling and load balancing [69, 78, 4, 9, 70, 72, 42, 56, 16, 46, 63, 45], matching [49, 35, 25, 56, 5, 15, 67, 73, 24], matroid intersection [27], set cover [53, 1, 20, 57, 21, 7, 74, 76, 30, 18, 75], graph coloring [77], edge coloring [19], edge orientation [26, 71, 13], online learning [60], maximal independent sets [33, 6, 12], broadcast range assignment [39], spanners [11, 23], discrepancy [52], chasing positive bodies [17], submodular maximization [40, 41, 29], submodular cover [57], or knapsack [32].
Fully dynamic online Steiner tree.
Imase and Waxman’s -recourse result for Steiner tree [59] in fact also holds in a more general setting where the input sequence consists of terminal insertions as well as deletions. For this setting, Łącki, Oćwieja, Pilipczuk, Sankowski, and Zych [65] gave a constant-competitive algorithm with recourse, where is the ratio of the maximum to minimum distance in the metric. Gupta and Kumar [54] improved this to recourse. Gupta and Levin [57] recovered the result of [65] in a more general setting of submodular cover. In all of these results, the recourse bounds are amortized.
1.3 Technical Overview
A natural attempt at maintaining an online -approximate Steiner forest is to, for each arrival in the input sequence, independently define the current snapshot of the online solution as the outcome of some offline -approximate algorithm for the current instance. This approach will automatically give an -approximate online solution. To control the recourse, the low-recourse online Steiner tree algorithm [50] exploits a well-behaved offline algorithm which constructs an offline solution under the guidance of a clustering procedure.
To design a low-recourse online Steiner forest algorithm, we also start with this framework, and fortunately, a generalized clustering procedure already exists for the Steiner forest problem [55]. However, the following fundamental difference between clustering procedures for Steiner tree and Steiner forest problems prevents us from continuing with the same approach as in [50].
The Barrier.
On a high level, a clustering procedure will maintain a clustering (i.e., a partition) of the terminals and iteratively merge two active clusters in which are close enough in the contracted metric (we can think of the input metric as a complete weighted graph on the terminals222In our model, we assume that the input metric has no Steiner node, i.e., is a metric on terminals. See Section 2 and particularly Remark 3 for a further discussion. and of as the graph with each cluster contracted into a single vertex). In the clustering procedure for Steiner tree, clusters are always active, which means that the procedure is equivalent to merging clusters which are close in the original metric , and therefore, adding one edge to the solution suffices to simulate this merge. In contrast, in the clustering procedure for Steiner forest, some clusters will become inactive (i.e., they will stay in the clustering without participating in further merge operations). Hence, we need to measure the closeness in the contracted metric , and thus simulating a merge operation between clusters requires us to add into the solution a - shortest path in , which potentially consists of many edges.
We note that the difference between the clustering procedures for these two problems is rooted in the inherent difference between Steiner forest and Steiner tree: a Steiner tree solution must be connected, while a Steiner forest solution may not. This is also the fundamental barrier to overcome when designing Steiner forest algorithms in other settings (e.g., the offline and classic online settings).
In other words, while applying the approach in [50] to Steiner forest may control recourse with respect to merges and their revocations (that is, when comparing the clustering procedures for two consecutive arrivals and , some merges done at may be revoked, and new merges may be performed at ), it remains unclear how to bound the recourse in terms of edge changes.
Step 1: Pinning Edges.
We proceed completely differently from [50] and use the idea of pinning edges. On a high level, when performing a merge by buying a shortest path, we pin the cheapest -fraction of edges on this path, where pinning an edge means that it will not be deleted in the future, even if the corresponding merge is later revoked. To bound the recourse without harming the approximation, we will guarantee the following.
-
The number of pinned edges is linear in at the end, which means that the total recourse will be bounded by . This is relatively simple: intuitively, we will enforce the set of pinned edges to be acyclic.
-
The cost of the pinned edges should always be within a constant factor of the optimum, so that we can still guarantee a constant-factor approximation. To this end, an important step is to bound the total cost of all merges throughout the algorithm by , including those that are later revoked (see the following Step 2 for a detailed discussion). This will bound the total cost of pinned edges by , since whenever we buy a path, the cheapest -fraction of its edges, which we pin, have cost at most -fraction of the path cost.
Step 2: Bounding the Total Merging Cost.
We employ a particular clustering procedure from the offline timed gluttonous algorithm [55]. It proceeds by levels, from to the top. At each level , it iteratively merges two clusters if their distance is in (the merging cost is at most their distance). Furthermore, the clustering procedure allows some flexibility in choosing the order of level- merges; intuitively, we prioritize the level- merges that already existed in the previous arrival.
For the above clustering procedure, we can show that for a fixed level , the cost of all merging operations at this level throughout the algorithm is bounded by using a dual-fitting framework. At a high level, the dual-fitting argument is intuitive: we want to maintain a set of source vertices and obtain a feasible dual solution by growing balls around them. The subtlety in the formal analysis is that choosing (and maintaining) the right source vertices requires exploiting how the offline clustering procedures relate to one another across different arrivals.
Finally, the total merging cost is , since the merges from levels beyond the top will have negligible costs. We emphasize that this total merging cost is not the cost of our online solution. The online solution consists of (i) the output of an offline -approximate algorithm for the current instance, and (ii) the edges pinned up to that point, which have cost as long as the total merging cost is .
1.4 Outline
In Section 2, we introduce the problem setting and notation. In Section 3, we describe an offline clustering procedure from the timed gluttonous algorithm [55], which will be used in our online algorithm. In Section 4, we show our algorithm for maintaining a forest based on the clustering procedure while incurring little recourse. Lastly, we discuss open problems in Section 5.
2 Preliminaries
We use to denote an (offline) Steiner forest instance, where is a set of demand pairs, and is a metric on the terminals . We call the mate of (and vice versa). We assume takes values at least , but do not require it to be bounded by a polynomial of , so this assumption is without loss of generality by scaling. For ease of presentation, we assume that each terminal participates in exactly one demand pair. The more general case, where a terminal may belong to multiple demand pairs, can be handled without additional difficulty333More explicitly, if two terminals and are at the same point of , we may replace with and at distance , and then scale all distances by ..
The graph representation of the metric is an undirected complete graph , where each edge has cost . Without ambiguity, we use to denote this original graph and we call edges in original edges (to differentiate them from virtual edges that we introduce later). A feasible solution to the Steiner forest instance is a subset of original edges such that each demand pair has and connected in the subgraph . We do not require a feasible solution to be acyclic (a forest), but note that an optimal solution must be a forest.
In the online setting, the instance is given in an online fashion. At each moment (called arrival) , a demand pair arrives. Moreover, and for all arrived terminals are revealed. In other words, if we let denote the set of arrived demand pairs and denote the arrived terminals, then after this arrival, we only know the submetric of induced by .
For the online instance , an online solution has competitive ratio and amortized recourse if each is an -approximate solution to the instance , and the total number of edge insertions and deletions required to maintain the online solution across all arrivals is at most .
Remark 3.
The way we define a Steiner forest instance may seem unusual in the sense that is a metric only on the set of terminals (without Steiner vertices). However, we point out that this model is in fact common in the literature on online Steiner trees with low recourse [68, 50, 54]. The motivation for this definition is that maintaining a Steiner tree/forest in a general (non-metric) graph with low recourse is unrealistic, since even purchasing a simple path between two terminals can already incur large recourse.444In the seminal work [59] on online Steiner trees with recourse, the authors consider a different model in which recourse is measured by the number of primitive path insertions and deletions, allowing them to work with general graphs. Moreover, restricting to the terminal-only metric increases the solution cost by at most a factor of 2 compared to the general model, so this model still captures the Steiner forest problem well, particularly when we aim for an -approximation.
Remark 4.
We assume that, at the beginning, we know [a constant-estimation of] the length of the online instance . This assumption can be easily removed as follows. Initially, set the estimation to be a constant. Whenever the current number of arrivals exceeds , we double and restart the entire algorithm. Note that these restarts will only increase the final amortized recourse by a constant factor.
Clusterings.
Given a terminal set , a clustering is a partitioning of into clusters. The trivial clustering is the one in which each terminal forms its own singleton cluster. For two clusterings and (they can be clusterings of different terminal sets and ), we write if each cluster is contained in some cluster , i.e., . Note that if , there must be .
Contracted Metrics.
Given an original metric and a clustering of , consider the graph obtained by contracting each cluster in the graph representation of the original metric into a single vertex representing . Note that the vertex set of this graph is exactly . We refer to the shortest-path metric of this graph as , and denote this graph by .
Sometimes we will further contract the graph by a subset of original edges. That is, consider edges one by one, and for each , contract the two vertices corresponding to into a single vertex (it is possible that correspond to the same vertex in the current graph, in which case we do nothing). We denote the resulting graph by , and use to denote its shortest-path metric. The vertex set of naturally corresponds to a partition of the vertex set of (which is exactly ), so for , can be defined naturally and it is unambiguous to talk about a - shortest path in .
3 A Clustering Procedure
In this section, we describe a clustering procedure which is the core part of the offline constant-approximate Steiner forest algorithm (called the timed gluttonous algorithm) in [55].
The input of the clustering procedure is a Steiner forest instance , and it outputs a clustering hierarchy of the terminal set , where denotes the maximum level (which will be defined shortly). The hierarchy satisfies that is the trivial clustering of , and for each , .
The Clustering Procedure.
Initially, for each terminal , define its level to be
where is the mate of . Note that since we have assumed takes values at least . The level of a cluster is . Let be the maximum level.
Then we iterate from to . For each iteration , we will construct based on as follows.
-
1.
First, we construct an auxiliary graph , called the virtual graph, with vertices
corresponding to clusters with , called -active clusters. Naturally, each with is an -inactive cluster. For each , there is an edge (called a virtual edge) in connecting them iff
-
2.
We construct by contracting over . That is, we first copy all -inactive clusters from into . Next, for each connected component of , we add a cluster into which is the union of all -clusters in this connected component, i.e., (note that the added in this way are -active). Note that by the construction.
We note that the above clustering procedure is identical to that in Section 4.1 of [55], so we list some observations below without formal proofs. These observations will be useful when analyzing our online algorithm in Section 4.
Observation 5.
For each and any two different -active clusters , we have .
The above Observation 5 follows because in iteration , we merge two -active clusters in if they are close (i.e., they have distance less than in ). A formal proof can be found in Section 4 in [55].
Observation 6.
For each demand pair , there is a cluster such that .
This is basically because by the definitions of and . Then at the beginning of iteration , if and are still inside different clusters , then and are still -active and they will be merged in this iteration.
The Forest-Forming Procedure.
For better understanding, we briefly describe a procedure forming a Steiner forest solution based on the clustering hierarchy (which is actually straightforward). However, we are not going to formally show the feasibility and approximation of this procedure, since the forest-forming procedure in our online algorithm is specialized.
We initialize an empty solution . For each from to , we select an arbitrary virtual spanning forest of the virtual graph , and then for each virtual edge connecting two clusters , add into the original edges on a - shortest path in the graph . Note that the path has cost at most , as guaranteed by the definition of virtual edges in Step 1.
The feasibility of the solution basically comes from Observation 6, and the approximation is given by the following Lemma 7, which will also be useful when analyzing the approximation of our online algorithm in Section 4. Lemma 7 is proved almost explicitly555The in their proof is exactly in our context. They show that . Combining this with gives Lemma 7. in the proof of Theorem 4.2 in [55].
Lemma 7 ([55]).
Let be the cost of an optimal solution to the instance . Then
Let us explain Lemma 7 somewhat further. The left-hand side takes a summation over all levels . For each level , observe that . Hence the inequality basically says that if we assign a budget of to each virtual edge in , then the total budget is within a constant factor of . Indeed, the cost of the original edges added into the real solution by each virtual edge is within the budget.
4 Our Online Algorithm
In this section, we will present our online Steiner forest algorithm with low recourse, and prove Theorem 8.
Theorem 8.
There is an algorithm for online Steiner forest that, over the course of arrivals of terminal pairs in a metric space, maintains an -competitive solution while inserting and deleting at most edges, for any .
Throughout this section, is the tradeoff parameter in Theorem 8, and Theorem 1 follows Theorem 8 by setting .
We start with Section 4.1, in which we will apply the clustering procedure from Section 3 for each arrival and introduce some notation and observations regarding the clustering hierarchies. Next, in Section 4.2, we define the online Steiner forest solution algorithmically by, for each arrival , constructing the snapshot of based on the current clustering hierarchy. Finally, Theorem 8 follows from the analyses of feasibility, recourse, and approximation in Section 4.3, Section 4.4, and Section 4.5, respectively.
For convenience, we provide an outline of the full online algorithm as Algorithm 2 (page 2). The details of each step are still described in the text of Section 4.2.
4.1 Applying the Clustering Procedure
We start with some notation. Let be the given online instance. For each arrival , we run the clustering procedure for the (offline) instance . Here we will write the corresponding variables (the maximum level), (the virtual graph at level ), (the clustering at level ), and (the clustering hierarchy) with a superscript . To avoid clutter, for each arrival and , we let be the same as the top-level clustering , and let be an empty virtual graph. Furthermore, for , we define and each and to be empty. The Lemma 9 below will be useful later.
Lemma 9.
For each and , we have .
Proof.
We prove this by induction on . Since is the trivial clustering on the terminal set and is the trivial clustering on the terminal set , the base case is true. Now assume for some fixed , . We will show . In other words, our goal is to show that a cluster is fully contained in some cluster of . To this end, we consider the connected components of and the connected components of . Note that if some two clusters have
then, since , we also have that for the parent clusters which contain and respectively,
Therefore, an edge between and in is also an edge between and in . So, if a cluster results from some connected component in consisting of , then there is a corresponding connected component of in (note that the are not necessarily distinct). This proves our inductive step.
4.2 Constructing the Snapshots of the Online Solution
Consider an arrival . We construct the snapshot of the online solution in two phases.
The First Phase.
We first construct a virtual solution using virtual edges in the virtual graphs for all . Similarly to the forest-forming procedure in Section 3, for each level , we will pick a virtual spanning forest of . However, rather than choosing an arbitrary forest as , we will choose more carefully, as we discuss shortly. The virtual solution is simply the union of virtual spanning forests at all levels.
Inheritable and Inherited Virtual Edges. Before describing how to choose , we need to introduce the concepts of inheritable/non-inheritable and inherited/non-inherited virtual edges.
For each virtual edge , it is inheritable if are not contained in the same -cluster (recall that from Lemma 9), otherwise it is non-inheritable.
Lemma 10.
For each inheritable virtual edge , there is a virtual edge connecting , the two different -clusters containing respectively.
Proof.
In the same vein as the proof above, note that if is an inheritable virtual edge in , then: (1) are contained in distinct clusters and in , and (2) . The second property implies , and therefore we will have an edge connecting and .
Lemma 10 naturally defines a mapping from the inheritable virtual edges in to virtual edges in . We define the inherited virtual edges in to be the image set of , and will call the other virtual edges in non-inherited. For each inherited virtual edge , we fix an arbitrary inheritable virtual edge with as the parent of , and say that is inherited from its parent .
Choosing . Now, we pick the virtual spanning forest giving priority to the inherited virtual edges in . Formally speaking, we first pick an arbitrary spanning forest in , the subgraph of induced by the inherited virtual edges. Then we arbitrarily augment to be a spanning forest of .
For better understanding, we emphasize that virtual edges in are classified in two ways: inheritable vs. non-inheritable, and inherited () vs. non-inherited (). Each inherited virtual edge in is inherited from its parent, some inheritable virtual edge in . However, not every inheritable virtual edge in may serve as the parent of an inherited virtual edge in .
Note that is exactly the clustering obtained by contracting over (the meaning of contracting is the same as in Step 2 of the clustering procedure), and we let denote the clustering obtained by contracting over . Then we have the following Lemma 11 which will be useful later.
Lemma 11.
.
Proof.
Assume for contradiction that there exists a cluster such that intersects two different clusters in .
First, we claim that is -active. Assume the opposite. We must have by the description of the clustering procedure. By Lemma 9, we know
Hence is contained in some cluster in , a contradiction.
Given that is -active, it is the union of several -active clusters in by the clustering procedure. Then, by and the assumption that intersects two different clusters in , there must be two different -active -clusters and inside such that they are contained by different -clusters.
Let and be the -clusters containing and respectively (we use from Lemma 9 again). If and are the same, combining it with already leads to a contradiction. Hence we assume and are different clusters. Now, we have already known that and are in the same connected component of (i.e., they are connected by the virtual spanning forest ). From the inheritance relation between -virtual edges and -virtual edges, it is straightforward to see that and are in the same connected component of , which means they are contained by the same -cluster, a contradiction.
The Second Phase.
In the second phase, we will construct the snapshot based on the virtual solution . A natural attempt is to proceed analogously to the offline forest-forming procedure in Section 3: for each virtual edge , add into a - shortest path in the metric . This will give a feasible with good approximation as we discussed in Section 3. However, it gives no control over the recourse: such a shortest path may be made up of many original edges in the original metric .
We fix this issue by pinning edges. Roughly speaking, whenever we add a shortest path, we pin some fraction of its original edges. Pinning an original edge means that we will never remove it from our online solution. We will guarantee two properties of the pinned edges. First, the total cost of pinned edges is always within a constant factor of the optimum, so that the online solution can achieve a constant competitive ratio. Second, the number of pinned edges grows linearly in , so that we can achieve low recourse by charging the number of original edge insertions to the number of pinned edges. We now formalize this argument.
As demands arrive, we will maintain a growing set of pinned edges. Our job in the current arrival is to assign to each virtual edge a set of original edges in , denoted by . From the previous arrival , we are already given the pinned edge set and the original edge set of every virtual edge . Meanwhile, we will also update the pinned edge set from to . The original solution is then
For each inherited virtual edge , its original edge set is simply
where is the parent of . As for pinning, on a high level, we add a fraction of the original edges to (selecting the cheapest ones); if there are fewer than many, we use a buffer set. More precisely, the original edge sets of the non-inherited virtual edges and the update from to are given by the following algorithm.
We note that we define the buffer to be a multiset just for ease of analysis. Defining as a set instead will not affect the correctness.
Finally, to enhance understanding, we outline our entire online algorithm in Algorithm 2.
4.3 Feasibility
To prove feasibility, it suffices to show that virtual edges between two clusters and do indeed correspond to real edge sets which connect and .
Lemma 12.
For each arrival , level , and virtual edge , the clusters and belong to the same vertex in the graph .
Proof.
If is a non-inherited virtual edge, this statement directly follows from Lines 4 and 5 of Algorithm 1. Concretely, at the moment is defined at Line 5, and clearly belong to the same vertex in by definition. Therefore, at the end of arrival , since only grows during Algorithm 1, the statement also holds.
The argument for an inherited virtual edge is similar, but we need induction to formally prove it. Assume inductively that the statement of Lemma 12 holds for all virtual edges in . Let be the parent of , which means , and . Then the statement holds for by the induction hypothesis and because
And so, since virtually connects up demands in the arrived demand set (by Observation 6), we know that will be a feasible solution.
4.4 Recourse
We are going to bound the total number of edge insertions by , that is,
which gives amortized recourse (since the number of edge deletions does not exceed the number of edge insertions).
Consider the changes from to . The new edges come from either or (since each inherited has ). In other words, we have
For the pinned edge set, we have by the fact that only grows and by the following Lemma 13.
Lemma 13.
There are at most pinned edges, i.e., .
Proof.
Observe that whenever we pin several edges at Line 7 or one edge at Line 12, the new pinned edges do not form a cycle with the existing pinned edges on the terminal set . Hence at the end is a forest on , which implies that .
Next, we charge the total size of original edge sets of non-inherited virtual edges (non-inherited original edge sets for short) to the number of pinned edges. In every execution of Line 7, we charge each new pinned edge a fee of units to account for , which is feasible because
when and (guaranteed by Line 11). In every execution of Line 12, again charge the new pinned edge a fee of units to account for , which is available because (right before Line 10, the buffer has size less than , and the current has size less than ). Finally, observe that every non-inherited original edge set is accounted for in the charging argument (either directly or via the buffer ), except for those remaining in the buffer at the end of each arrival (at these moments, ). Therefore, we have
4.5 Approximation
To avoid clutter, we only show that after the last arrival , the online solution is an -approximation to the instance . The approximation in the other arrivals can be bounded in exactly the same way.
Let be the cost of the optimal solution to . Recall that
Hence, to bound the cost of by , it suffices to bound
-
(called the pinning cost) by , and
-
(called the forest-forming cost) by .
The Forest-Forming Cost.
The forest-forming cost can be interpreted as the cost of the offline Steiner forest algorithm introduced in Section 3, which can be directly bounded by Lemma 7.
Formally, for each level and each virtual edge , we have
| (1) |
To see this, we trace back through the inheritance relation until reaching a non-inherited virtual edge in some arrival . At the moment when is defined on Lines 4 and 5 of Algorithm 1, we have
| (2) |
where the last inequality is by and the definition of . The inheritance relation implies , so we get the desired bound (1).
The Pinning Cost.
Algorithm 1 pins roughly a -fraction of edges from the non-inherited original edge sets, so naturally the first step is to bound the total cost of non-inherited original edge sets.
Theorem 14.
For each level we have
| (3) |
We say that a non-inherited original edge set is from level if its corresponding non-inherited virtual edge is from for some . Theorem 14 above shows that for each level , the total cost of non-inherited original edge sets summed over all arrivals is bounded by (note that each non-inherited original edge set has cost at most as we argued in (2)).
We prove Theorem 14 in Section 4.6 below. Given Theorem 14, the intuition for bounding the pinning cost is as follows. If we assume that there are levels, then Theorem 14 shows that the total cost of non-inherited original edge sets is , so the pinning cost can be bounded by since we pinned roughly a fraction. Without the assumption of levels, the intuition is that non-inherited original edge sets not from the top levels have negligible costs. We formalize this intuition as follows.
To see , by Lemma 13 it suffices to show , where are pinned edges with non-negligible costs. Note that will only grow at Lines 7 and 12 in Algorithm 1.
Line 7. Consider an execution of Line 7 that brings new -pinned edges. The current non-inherited original edge set must come from the top levels (i.e., the current level is between and the maximum level ). Otherwise, we have (note that by the definition of the function ), and any pinned edge from would have negligible cost. Furthermore, the algorithm guarantees that the total cost of new -pinned edges from this execution is at most .
Line 12. Suppose an execution of Line 12 brings a new -pinned edge. Note that at this moment, the buffer is the multiset union of several non-inherited original edge sets, all of which come from the top levels by the same argument as in the previous case. Again, the algorithm guarantees the cost of this new -pinned edge is at most .
Finally, observe that the sum of over such executions of Line 7 (which brings new edges) and over such executions of Line 12 is at most by Theorem 14 (since the involved non-inherited original edge sets are all from the top levels), so we get and .
4.6 Proof of Theorem 14
We will invoke a fact that forms the initial part of the analysis in [55]. By losing a constant factor in cost, it allows us to assume that the clustering induced by our solution is a refinement of that of the optimal solution (in [55] this is called the faithfulness property). For clarity, we refer to as , which is the top-level clustering of the hierarchy after the last arrival.
Lemma 15 (Theorem 4.1 in [55]).
There exists a solution of the instance satisfying that
-
the cost of is at most , and
-
for each cluster ,
all vertices in belong to the same connected component of .
Now we prove Theorem 14 using Lemma 15. We restate Theorem 14 for ease of reading.
Theorem 14. [Restated, see original statement.]
For each level we have
| (3) |
Proof.
We use a dual fitting argument.
Primal LP and its Dual.
Consider the following primal LP, where is the family of all cuts separating at least one cluster in , i.e., there exists a with and . For each cut , we use to denote the set of original edges crossing .
| s.t. | |||
Note that this primal LP does not exactly correspond to the instance , since it requires the solution to have stronger connectivity (each cluster in should have all its vertices connected). However, its optimal value will not exceed too much, i.e., we have
because the solution in Lemma 15 gives a feasible solution (for each , set if , otherwise ) to the LP with cost at most . The dual LP is as follows:
| s.t. | |||
An intermediate goal is to construct a feasible dual solution with value approximately the LHS of (3). We slightly abuse notation by viewing a dual solution as a function , and we say such a dual solution is feasible if it satisfies the dual constraints and is zero outside the actual domain .
Construction of the Dual Solution .
We start with some standard terminology of the dual-fitting argument. Consider a vertex , and let be an order of vertices with increasing (in particular ). By growing a ball with radius around , we mean for each with , adding a value to the dual variable . The following observation is straightforward by the triangle inequality.
Observation 16.
Let be a set of vertices with pairwise distances at least in . Then the dual solution obtained by growing a ball of radius around each vertex in satisfies all the dual constraints.
The dual solution we will construct is exactly by growing a ball of radius around each vertex in a subset . We set the radius
and define the subset by the following procedure.
The procedure will define subsets and for each arrival . We will take the final to be (corresponding to the last arrival). The subsets will be defined so as to satisfy the following invariants:
-
1.
is contained in the union of -active clusters in . Recall that -active clusters are the clusters with .
-
2.
Vertices in have pairwise distances at least in .
-
3.
, and for each -active cluster , has at least one vertex outside .
-
4.
.
In particular, if some arrival has maximum level less than , then and are simply empty, which clearly satisfy all the invariants. In what follows, we first describe the construction of and , and then argue why taking gives a feasible dual solution.
We now construct and assuming that and (satisfying the invariants) are given. Recall the following from Section 4.2: is exactly the clustering obtained by contracting over . The virtual edges are inherited. is an intermediate clustering obtained by contracting over .
Useful Properties on Clusterings. The argument below will heavily exploit some useful properties of clusterings and . First, directly from the clustering procedure, we have
Second, recall that Lemma 9 and Lemma 11 provide
We sometimes consider the union of -active clusters in these clusterings. Let denote the union of -active clusters in a clustering . We can easily observe that
by the clustering procedure and the above properties.
Construction of . Let be the new demand pair of arrival . Initially, set . If , let be the clusters containing and respectively (possibly and are the same cluster).
-
If and are the same cluster, add into if and are the only vertices with level at least in .
-
If and are different clusters, add (resp. ) into if (resp. ) are the only vertices with level at least in (resp. ).
Lemma 17.
We have the following.
-
1.
is contained in the union of -active clusters in , i.e., .
-
2.
Vertices in have pairwise distances at least in .
-
3.
For each -active cluster , has at least one vertex outside .
Proof.
Item 1 is straightforward from the construction of : the new vertices of (i.e., one or more of and ) always come from the -active clusters ; the old vertices of satisfy (by Invariant 1), and thus .
Next, we show Item 2. Suppose and are different clusters (an analogous argument works for the case ). It suffices to show that if we add into , this new is far from any vertices in . Recall that we add only if is the only vertex with level at least in . This means the -active cluster containing also has as the only vertex with level at least (since ), and thus, is disjoint from any -active cluster in (since ). Therefore, is disjoint from .
Now consider any vertex . It must belong to an -active -cluster (since ), and this cannot be the same as (since is disjoint from ). Hence, we can conclude
as desired, where the second inequality is by Observation 5.
Regarding Item 3, if an -active cluster contains an -active cluster in , then by Invariant 3 of , will have at least one vertex outside . Thus, we only need to pay attention to those -active clusters containing no -active cluster in . Because (Lemma 11), such a cluster must have no vertex with level at least from . In other words, such a cluster exists only when (since is -active) and it must contain either or (or both). Then by our construction of , we indeed add a new vertex from into as desired.
Construction of . Initially, set .
Observation 18.
Each -active cluster in is contained by an -active cluster in . Each -active cluster in only contains -active clusters in .
Proof.
This is simply because, from to , the clustering procedure only merges -active clusters.
For each -active cluster , if it is made up of many -active clusters in , then by Item 3 in Lemma 17, has at least vertices outside , and we add arbitrary of them into .
Proving Invariants of and . Invariant 1 is by Item 1 in Lemma 17 and the fact that the union of -active clusters in is the same as that in . Invariant 2 has also been proven in Lemma 17. Invariant 3 is by the construction of .
Finally, to see Invariant 4, it suffices to show that . Furthermore, we can observe that , since is obtained by contracting over , and similarly, we have . By the construction of , the number of new vertices added to , i.e., , is exactly the number of -active clusters in minus the number of -active clusters in , which is the same as since the -inactive clusters in are the same as those in . Combining all the above, we get .
Feasibility of the Dual Solution .
Recall that we have two steps to show the feasibility of the dual solution . First, it is required that satisfies all the dual constraints, which is indeed the case by Observation 16 and the way we construct . Second, we also need to show that is zero outside the actual domain (recall that collects all cuts separating at least one cluster in ).
Consider a vertex . When we grow a ball with radius around , the cuts for which we may add a positive value to must satisfy . However, by Invariants 1, 2 and 3, in the cluster containing , there must be another vertex such that . Hence is outside all such cuts , which means that all such will separate . Finally, since , all such will separate the -cluster containing , as desired.
Completing the Proof.
5 Conclusion
In this work we initiate the study of low-recourse algorithms for online Steiner forest. We gave a constant-competitive algorithm with amortized recourse. This prompts several natural follow-up questions:
Question 19.
Is there an algorithm with recourse?
Question 20.
Can the recourse be de-amortized?
Question 21.
Can one handle the fully-dynamic setting, where terminal pairs both arrive and depart? (What about the deletion-only model?)
For completeness, we also remark that for the Steiner tree problem, an algorithm with worst-case (un-amortized) constant recourse is not known for the fully dynamic setting.
Remark 22.
Obtaining recourse in the deletion-only setting (of online Steiner forest) is straightforward, at least if we assume that the optimal cost is bounded polynomially in : one can recompute the solution whenever the optimal cost decreases by a factor 2.666We can further remove the assumption by bucketing the demand pairs. That is, initially, we put a pair with into the -th bucket, and then for each bucket , create its own initial solution (let the entire initial solution be the union of all ). Note that should be proportional to the bucket size, since the original graph is complete with edge weights forming a metric. With this initial solution, whenever the optimal cost is halved, we only need to recompute the of the top buckets. Each is recomputed times, leading to amortized recourse.
References
- [1] Amir Abboud, Raghavendra Addanki, Fabrizio Grandoni, Debmalya Panigrahi, and Barna Saha. Dynamic set cover: improved algorithms and lower bounds. In Moses Charikar and Edith Cohen, editors, Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, STOC 2019, Phoenix, AZ, USA, June 23-26, 2019, pages 114–125. ACM, 2019. doi:10.1145/3313276.3316376.
- [2] Ajit Agrawal, Philip N. Klein, and R. Ravi. When trees collide: An approximation algorithm for the generalized steiner problem on networks. SIAM J. Comput., 24(3):440–456, 1995. doi:10.1137/S0097539792236237.
- [3] Ali Ahmadi, Iman Gholami, MohammadTaghi Hajiaghayi, Peyman Jabbarzade, and Mohammad Mahdavi. Breaking a long-standing barrier: 2- approximation for steiner forest. In 66th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2025, Sydney, Australia, December 14-17, 2025, pages 373–444. IEEE, 2025. doi:10.1109/FOCS63196.2025.00023.
- [4] Matthew Andrews, Michel X. Goemans, and Lisa Zhang. Improved bounds for on-line load balancing. Algorithmica, 23(4):278–301, 1999. doi:10.1007/PL00009263.
- [5] Spyros Angelopoulos, Christoph Dürr, and Shendan Jin. Online maximum matching with recourse. In Igor Potapov, Paul G. Spirakis, and James Worrell, editors, 43rd International Symposium on Mathematical Foundations of Computer Science, MFCS 2018, August 27-31, 2018, Liverpool, UK, volume 117 of LIPIcs, pages 8:1–8:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.MFCS.2018.8.
- [6] Sepehr Assadi, Krzysztof Onak, Baruch Schieber, and Shay Solomon. Fully dynamic maximal independent set with sublinear update time. In Ilias Diakonikolas, David Kempe, and Monika Henzinger, editors, Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2018, Los Angeles, CA, USA, June 25-29, 2018, pages 815–826. ACM, 2018. doi:10.1145/3188745.3188922.
- [7] Sepehr Assadi and Shay Solomon. Fully dynamic set cover via hypergraph maximal matching: An optimal approximation through a local approach. In Petra Mutzel, Rasmus Pagh, and Grzegorz Herman, editors, 29th Annual European Symposium on Algorithms, ESA 2021, September 6-8, 2021, Lisbon, Portugal (Virtual Conference), volume 204 of LIPIcs, pages 8:1–8:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ESA.2021.8.
- [8] Baruch Awerbuch, Yossi Azar, and Yair Bartal. On-line generalized steiner problem. In Éva Tardos, editor, Proceedings of the Seventh Annual ACM-SIAM Symposium on Discrete Algorithms, 28-30 January 1996, Atlanta, Georgia, USA, pages 68–74. ACM/SIAM, 1996. URL: http://dl.acm.org/citation.cfm?id=313852.313888.
- [9] Baruch Awerbuch, Yossi Azar, Serge A. Plotkin, and Orli Waarts. Competitive routing of virtual circuits with unknown duration. J. Comput. Syst. Sci., 62(3):385–397, 2001. doi:10.1006/jcss.1999.1662.
- [10] Étienne Bamas, Marina Drygala, and Andreas Maggiori. An improved analysis of greedy for online steiner forest. In Joseph (Seffi) Naor and Niv Buchbinder, editors, Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, Virtual Conference / Alexandria, VA, USA, January 9 - 12, 2022, pages 3202–3229. SIAM, SIAM, 2022. doi:10.1137/1.9781611977073.125.
- [11] Surender Baswana, Sumeet Khurana, and Soumojit Sarkar. Fully dynamic randomized algorithms for graph spanners. ACM Trans. Algorithms, 8(4), October 2012. doi:10.1145/2344422.2344425.
- [12] Soheil Behnezhad, Mahsa Derakhshan, MohammadTaghi Hajiaghayi, Cliff Stein, and Madhu Sudan. Fully dynamic maximal independent set with polylogarithmic update time. In David Zuckerman, editor, 60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Baltimore, Maryland, USA, November 9-12, 2019, pages 382–405. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00032.
- [13] Suman K. Bera, Sayan Bhattacharya, Jayesh Choudhari, and Prantar Ghosh. A new dynamic algorithm for densest subhypergraphs. In Frédérique Laforest, Raphaël Troncy, Elena Simperl, Deepak Agarwal, Aristides Gionis, Ivan Herman, and Lionel Médini, editors, WWW ’22: The ACM Web Conference 2022, Virtual Event, Lyon, France, April 25 - 29, 2022, pages 1093–1103. ACM, 2022. doi:10.1145/3485447.3512158.
- [14] Piotr Berman and Chris Coulston. On-line algorithms for steiner tree problems (extended abstract). In Frank Thomson Leighton and Peter W. Shor, editors, Proceedings of the Twenty-Ninth Annual ACM Symposium on Theory of Computing, STOC ’97, pages 344–353, New York, NY, USA, 1997. Association for Computing Machinery. doi:10.1145/258533.258618.
- [15] Aaron Bernstein, Jacob Holm, and Eva Rotenberg. Online bipartite matching with amortized o(log 2 n) replacements. J. ACM, 66(5), September 2019. doi:10.1145/3344999.
- [16] Aaron Bernstein, Tsvi Kopelowitz, Seth Pettie, Ely Porat, and Clifford Stein. Simultaneously Load Balancing for Every p-norm, With Reassignments. In Christos H. Papadimitriou, editor, 8th Innovations in Theoretical Computer Science Conference (ITCS 2017), volume 67 of Leibniz International Proceedings in Informatics (LIPIcs), pages 51:1–51:14, Dagstuhl, Germany, 2017. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ITCS.2017.51.
- [17] Sayan Bhattacharya, Niv Buchbinder, Roie Levin, and Thatchaphol Saranurak. Chasing positive bodies. In 2023 IEEE 64th Annual Symposium on Foundations of Computer Science (FOCS), pages 1694–1714, 2023. doi:10.1109/FOCS57990.2023.00103.
- [18] Sayan Bhattacharya, Ruoxu Cen, and Debmalya Panigrahi. Fully dynamic set cover: Worst-case recourse and update time. CoRR, abs/2511.08485, 2025. To appear in Proceedings of the 58th Annual ACM Symposium on Theory of Computing (STOC 2026). doi:10.48550/arXiv.2511.08485.
- [19] Sayan Bhattacharya, Fabrizio Grandoni, and David Wajc. Online edge coloring algorithms via the nibble method. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA ’21), pages 2830–2841. SIAM, 2021. doi:10.1137/1.9781611976465.168.
- [20] Sayan Bhattacharya, Monika Henzinger, and Danupon Nanongkai. A new deterministic algorithm for dynamic set cover. In David Zuckerman, editor, 60th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2019, Baltimore, Maryland, USA, November 9-12, 2019, pages 406–423. IEEE Computer Society, 2019. doi:10.1109/FOCS.2019.00033.
- [21] Sayan Bhattacharya, Monika Henzinger, Danupon Nanongkai, and Xiaowei Wu. Dynamic set cover: Improved amortized and worst-case update time. In Dániel Marx, editor, Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms, SODA 2021, Virtual Conference, January 10 - 13, 2021, pages 2537–2549. SIAM, 2021. doi:10.1137/1.9781611976465.150.
- [22] Sayan Bhattacharya, Silvio Lattanzi, and Nikos Parotsidis. Efficient and stable fully dynamic facility location. In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh, editors, Advances in Neural Information Processing Systems 35: Annual Conference on Neural Information Processing Systems 2022, NeurIPS 2022, New Orleans, LA, USA, November 28 - December 9, 2022, 2022. URL: http://papers.nips.cc/paper_files/paper/2022/hash/943d6dca1884955e645d8997ae2fa938-Abstract-Conference.html.
- [23] Sayan Bhattacharya, Thatchaphol Saranurak, and Pattara Sukprasert. Simple dynamic spanners with near-optimal recourse against an adaptive adversary. In Shiri Chechik, Gonzalo Navarro, Eva Rotenberg, and Grzegorz Herman, editors, 30th Annual European Symposium on Algorithms, ESA 2022, September 5-9, 2022, Berlin/Potsdam, Germany, volume 244 of LIPIcs, pages 17:1–17:19. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ESA.2022.17.
- [24] Sujoy Bhore, Arnold Filtser, and Csaba D. Tóth. Online duet between metric embeddings and minimum-weight perfect matchings. In David P. Woodruff, editor, Proceedings of the 2024 ACM-SIAM Symposium on Discrete Algorithms, SODA 2024, Alexandria, VA, USA, January 7-10, 2024, pages 4564–4579. SIAM, 2024. doi:10.1137/1.9781611977912.162.
- [25] Bartlomiej Bosek, Dariusz Leniowski, Piotr Sankowski, and Anna Zych. Online bipartite matching in offline time. In 2014 IEEE 55th Annual Symposium on Foundations of Computer Science (FOCS), pages 384–393. IEEE, 2014. doi:10.1109/FOCS.2014.48.
- [26] Gerth Stølting Brodal and Rolf Fagerberg. Dynamic representations of sparse graphs. In Frank Dehne, Jörg-Rüdiger Sack, Arvind Gupta, and Roberto Tamassia, editors, Algorithms and Data Structures, pages 342–351, Berlin, Heidelberg, 1999. Springer Berlin Heidelberg. doi:10.1007/3-540-48447-7_34.
- [27] Niv Buchbinder, Anupam Gupta, Daniel Hathcock, Anna R. Karlin, and Sherry Sarkar. Maintaining matroid intersections online. In David P. Woodruff, editor, Proceedings of the 2024 ACM-SIAM Symposium on Discrete Algorithms, SODA 2024, Alexandria, VA, USA, January 7-10, 2024, pages 4283–4304. SIAM, 2024. doi:10.1137/1.9781611977912.149.
- [28] Niv Buchbinder, Roie Levin, and Yue Yang. Competitively consistent clustering. In Aarti Singh, Maryam Fazel, Daniel Hsu, Simon Lacoste-Julien, Felix Berkenkamp, Tegan Maharaj, Kiri Wagstaff, and Jerry Zhu, editors, Forty-second International Conference on Machine Learning, ICML 2025, Vancouver, BC, Canada, July 13-19, 2025, volume 267 of Proceedings of Machine Learning Research. PMLR / OpenReview.net, 2025. URL: https://proceedings.mlr.press/v267/buchbinder25a.html.
- [29] Niv Buchbinder, Joseph Naor, and David Wajc. Chasing submodular objectives, and submodular maximization via cutting planes. CoRR, abs/2511.13605, 2025. doi:10.48550/arXiv.2511.13605.
- [30] Anton Bukov, Shay Solomon, and Tianyi Zhang. Nearly optimal dynamic set cover: Breaking the quadratic-in-f time barrier. In Yossi Azar and Debmalya Panigrahi, editors, Proceedings of the 2025 Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2025, New Orleans, LA, USA, January 12-15, 2025, pages 824–863. SIAM, 2025. doi:10.1137/1.9781611978322.24.
- [31] Jaroslaw Byrka, Fabrizio Grandoni, Thomas Rothvoß, and Laura Sanita. An improved lp-based approximation for steiner tree. In Proceedings of the forty-second ACM symposium on Theory of computing, pages 583–592, 2010. doi:10.1145/1806689.1806769.
- [32] Hans-Joachim Böckenhauer, Ralf Klasing, Tobias Mömke, Peter Rossmanith, Moritz Stocker, and David Wehner. Online knapsack with removal and recourse. Journal of Computer and System Sciences, 155:103697, 2026. doi:10.1016/j.jcss.2025.103697.
- [33] Keren Censor-Hillel, Elad Haramaty, and Zohar S. Karnin. Optimal dynamic distributed MIS. In George Giakkoupis, editor, Proceedings of the 2016 ACM Symposium on Principles of Distributed Computing, PODC 2016, Chicago, IL, USA, July 25-28, 2016, pages 217–226. ACM, 2016. doi:10.1145/2933057.2933083.
- [34] T-H. Hubert Chan, Shaofeng H.-C. Jiang, Tianyi Wu, and Mengshi Zhao. Online clustering with nearly optimal consistency. In The Thirteenth International Conference on Learning Representations, 2025. URL: https://openreview.net/forum?id=NA2vUMaMOm.
- [35] Kamalika Chaudhuri, Constantinos Daskalakis, Robert D. Kleinberg, and Henry Lin. Online bipartite perfect matching with augmentations. In IEEE INFOCOM 2009, pages 1044–1052. IEEE, 2009. doi:10.1109/INFCOM.2009.5062016.
- [36] Ho-Lin Chen, Tim Roughgarden, and Gregory Valiant. Designing network protocols for good equilibria. SIAM Journal on Computing, 39(5):1799–1832, 2010. doi:10.1137/08072721X.
- [37] Miroslav Chlebík and Janka Chlebíková. The steiner tree problem on graphs: Inapproximability results. Theoretical Computer Science, 406(3):207–214, 2008. doi:10.1016/j.tcs.2008.06.046.
- [38] Vincent Cohen-Addad, Niklas Oskar D. Hjuler, Nikos Parotsidis, David Saulpic, and Chris Schwiegelshohn. Fully dynamic consistent facility location. In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d’Alché-Buc, Emily B. Fox, and Roman Garnett, editors, Advances in Neural Information Processing Systems (NeurIPS), pages 3250–3260, 2019. URL: https://proceedings.neurips.cc/paper/2019/hash/fface8385abbf94b4593a0ed53a0c70f-Abstract.html.
- [39] Mark de Berg, Arpan Sadhukhan, and Frits Spieksma. Stable approximation algorithms for the dynamic broadcast range-assignment problem. SIAM Journal on Discrete Mathematics, 38(1):790–827, 2024. doi:10.1137/23M1545975.
- [40] Paul Duetting, Federico Fusco, Silvio Lattanzi, Ashkan Norouzi-Fard, and Morteza Zadimoghaddam. Consistent submodular maximization. In Forty-first International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024. OpenReview.net, 2024. URL: https://openreview.net/forum?id=AlJkqMnyjL.
- [41] Paul Dütting, Federico Fusco, Silvio Lattanzi, Ashkan Norouzi-Fard, Ola Svensson, and Morteza Zadimoghaddam. The cost of consistency: Submodular maximization with constant recourse. In Michal Koucký and Nikhil Bansal, editors, Proceedings of the 57th Annual ACM Symposium on Theory of Computing, STOC 2025, Prague, Czechia, June 23-27, 2025, pages 1406–1417. ACM, 2025. doi:10.1145/3717823.3718131.
- [42] Leah Epstein and Asaf Levin. Robust algorithms for preemptive scheduling. Algorithmica, 69(1):26–57, 2014. doi:10.1007/s00453-012-9718-3.
- [43] Hendrik Fichtenberger, Silvio Lattanzi, Ashkan Norouzi-Fard, and Ola Svensson. Consistent k-clustering for general metrics. In Proceedings of the 2021 ACM-SIAM Symposium on Discrete Algorithms (SODA ’21), pages 2660–2678. SIAM, 2021. doi:10.1137/1.9781611976465.158.
- [44] Sebastian Forster and Antonis Skarlatos. Dynamic consistent k-center clustering with optimal recourse. In Proceedings of the 2025 ACM-SIAM Symposium on Discrete Algorithms (SODA ’25), pages 212–254. SIAM, 2025. doi:10.1137/1.9781611978322.7.
- [45] Ayoub Foussoul, Vineet Goyal, and Amit Kumar. Fully-dynamic load balancing. In Jens Vygen and Jaroslaw Byrka, editors, Integer Programming and Combinatorial Optimization - 25th International Conference, IPCO 2024, Wrocław, Poland, July 3-5, 2024, Proceedings, volume 14679 of Lecture Notes in Computer Science, pages 182–195. Springer, 2024. doi:10.1007/978-3-031-59835-7_14.
- [46] Waldo Gálvez, José A. Soto, and José Verschae. Symmetry exploitation for online machine covering with bounded migration. ACM Trans. Algorithms, 16(4):43:1–43:22, July 2020. doi:10.1145/3397535.
- [47] Michel X. Goemans and David P. Williamson. A general approximation technique for constrained forest problems. SIAM J. Comput., 24(2):296–317, 1995. doi:10.1137/S0097539793242618.
- [48] Martin Groß, Anupam Gupta, Amit Kumar, Jannik Matuschke, Daniel R. Schmidt, Melanie Schmidt, and José Verschae. A local-search algorithm for steiner forest. In Anna R. Karlin, editor, 9th Innovations in Theoretical Computer Science Conference, ITCS 2018, January 11-14, 2018, Cambridge, MA, USA, volume 94 of LIPIcs, pages 31:1–31:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.ITCS.2018.31.
- [49] Edward F. Grove, Ming-Yang Kao, P. Krishnan, and Jeffrey Scott Vitter. Online perfect matching and mobile computing. In Workshop on Algorithms and Data Structures, pages 194–205. Springer, 1995. doi:10.1007/3-540-60220-8_62.
- [50] Albert Gu, Anupam Gupta, and Amit Kumar. The power of deferral: maintaining a constant-competitive steiner tree online. In Dan Boneh, Tim Roughgarden, and Joan Feigenbaum, editors, Symposium on Theory of Computing Conference, STOC’13, Palo Alto, CA, USA, June 1-4, 2013, pages 525–534. ACM, 2013. doi:10.1145/2488608.2488674.
- [51] Xiangyu Guo, Janardhan Kulkarni, Shi Li, and Jiayi Xian. On the facility location problem in online and dynamic models. In Jaroslaw Byrka and Raghu Meka, editors, Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM 2020, August 17-19, 2020, Virtual Conference, volume 176 of LIPIcs, pages 42:1–42:23. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.APPROX/RANDOM.2020.42.
- [52] Anupam Gupta, Vijaykrishna Gurunathan, Ravishankar Krishnaswamy, Amit Kumar, and Sahil Singla. Online discrepancy with recourse for vectors and graphs. In Joseph (Seffi) Naor and Niv Buchbinder, editors, Proceedings of the 2022 ACM-SIAM Symposium on Discrete Algorithms, SODA 2022, Virtual Conference / Alexandria, VA, USA, January 9 - 12, 2022, pages 1356–1383. SIAM, 2022. doi:10.1137/1.9781611977073.57.
- [53] Anupam Gupta, Ravishankar Krishnaswamy, Amit Kumar, and Debmalya Panigrahi. Online and dynamic algorithms for set cover. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, STOC 2017, pages 537–550, New York, NY, USA, 2017. Association for Computing Machinery. doi:10.1145/3055399.3055493.
- [54] Anupam Gupta and Amit Kumar. Online steiner tree with deletions. In Proceedings of the twenty-fifth annual ACM-SIAM symposium on Discrete algorithms, pages 455–467. SIAM, 2014. doi:10.1137/1.9781611973402.34.
- [55] Anupam Gupta and Amit Kumar. Greedy algorithms for steiner forest. In Rocco A. Servedio and Ronitt Rubinfeld, editors, Proceedings of the Forty-Seventh Annual ACM on Symposium on Theory of Computing, STOC 2015, Portland, OR, USA, June 14-17, 2015, pages 871–878. ACM, 2015. doi:10.1145/2746539.2746590.
- [56] Anupam Gupta, Amit Kumar, and Cliff Stein. Maintaining assignments online: Matching, scheduling, and flows. In Chandra Chekuri, editor, Proceedings of the Twenty-Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA 2014, Portland, Oregon, USA, January 5-7, 2014, pages 468–479. SIAM, 2014. doi:10.1137/1.9781611973402.35.
- [57] Anupam Gupta and Roie Levin. Fully-dynamic submodular cover with bounded recourse. In Sandy Irani, editor, 61st IEEE Annual Symposium on Foundations of Computer Science, FOCS 2020, Durham, NC, USA, November 16-19, 2020, pages 1147–1157. IEEE, 2020. doi:10.1109/FOCS46700.2020.00110.
- [58] Anupam Gupta and Vera Traub. Steiner forest: A simplified better-than-2 approximation. CoRR, abs/2511.18460, 2025. To appear in Proceedings of the 58th Annual ACM Symposium on Theory of Computing (STOC 2026). doi:10.48550/arXiv.2511.18460.
- [59] Makoto Imase and Bernard M. Waxman. Dynamic steiner tree problem. SIAM J. Discret. Math., 4(3):369–384, 1991. doi:10.1137/0404033.
- [60] Mohammad Reza Karimi Jaghargh, Andreas Krause, Silvio Lattanzi, and Sergei Vassilvtiskii. Consistent online optimization: Convex and submodular. In Kamalika Chaudhuri and Masashi Sugiyama, editors, Proceedings of the Twenty-Second International Conference on Artificial Intelligence and Statistics, volume 89 of Proceedings of Machine Learning Research, pages 2241–2250. PMLR, 16–18 April 2019. URL: https://proceedings.mlr.press/v89/jaghargh19a.html.
- [61] Richard M. Karp. Reducibility among combinatorial problems. In Raymond E. Miller and James W. Thatcher, editors, Proceedings of Symposium on the Complexity of Computer Computations, pages 85–103. Plenum Press, New York, 1972. doi:10.1007/978-1-4684-2001-2_9.
- [62] Lawrence T. Kou, George Markowsky, and Leonard Berman. A fast algorithm for steiner trees. Acta Informatica, 15:141–145, 1981. doi:10.1007/BF00288961.
- [63] Ravishankar Krishnaswamy, Shi Li, and Varun Suriyanarayana. Online unrelated-machine load balancing and generalized flow with recourse. In Barna Saha and Rocco A. Servedio, editors, Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 775–788. ACM, 2023. doi:10.1145/3564246.3585222.
- [64] Jakub Łącki, Bernhard Haeupler, Christoph Grunau, Rajesh Jayaram, and Václav Rozhoň. Fully dynamic consistent k-center clustering. In Proceedings of the 2024 Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 3463–3484. SIAM, 2024. doi:10.1137/1.9781611977912.124.
- [65] Jakub Łącki, Jakub Oćwieja, Marcin Pilipczuk, Piotr Sankowski, and Anna Zych. The power of dynamic distance oracles: Efficient dynamic algorithms for the steiner tree. In Proceedings of the Forty-Seventh Annual ACM Symposium on Theory of Computing, STOC ’15, pages 11–20, New York, NY, USA, 2015. Association for Computing Machinery. doi:10.1145/2746539.2746615.
- [66] Silvio Lattanzi and Sergei Vassilvitskii. Consistent k-clustering. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning (ICML 2017), volume 70 of Proceedings of Machine Learning Research, pages 1975–1984. PMLR, August 2017. URL: https://proceedings.mlr.press/v70/lattanzi17a.html.
- [67] Nicole Megow and Lukas Nölke. Online Minimum Cost Matching with Recourse on the Line. In Jarosław Byrka and Raghu Meka, editors, Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2020), volume 176 of Leibniz International Proceedings in Informatics (LIPIcs), pages 37:1–37:16, Dagstuhl, Germany, 2020. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.APPROX/RANDOM.2020.37.
- [68] Nicole Megow, Martin Skutella, José Verschae, and Andreas Wiese. The power of recourse for online MST and TSP. In Artur Czumaj, Kurt Mehlhorn, Andrew M. Pitts, and Roger Wattenhofer, editors, Automata, Languages, and Programming - 39th International Colloquium, ICALP 2012, Warwick, UK, July 9-13, 2012, Proceedings, Part I, volume 7391 of Lecture Notes in Computer Science, pages 689–700. Springer, 2012. doi:10.1007/978-3-642-31594-7_58.
- [69] Steven Phillips and Jeffery Westbrook. Online load balancing and network flow. Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing (STOC), pages 402–411, 1993. doi:10.1145/167088.167201.
- [70] Peter Sanders, Naveen Sivadasan, and Martin Skutella. Online scheduling with bounded migration. Mathematics of Operations Research, 34(2):481–498, 2009. doi:10.1287/moor.1090.0381.
- [71] Saurabh Sawlani and Junxing Wang. Near-optimal fully dynamic densest subgraph. In Konstantin Makarychev, Yury Makarychev, Madhur Tulsiani, Gautam Kamath, and Julia Chuzhoy, editors, Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020, pages 181–193. ACM, 2020. doi:10.1145/3357713.3384327.
- [72] Martin Skutella and José Verschae. A robust PTAS for machine covering and packing. In Mark de Berg and Ulrich Meyer, editors, Algorithms - ESA 2010, 18th Annual European Symposium, Liverpool, UK, September 6-8, 2010. Proceedings, Part I, volume 6346 of Lecture Notes in Computer Science, pages 36–47. Springer, 2010. doi:10.1007/978-3-642-15775-2_4.
- [73] Noam Solomon and Shay Solomon. A generalized matching reconfiguration problem. In James R. Lee, editor, 12th Innovations in Theoretical Computer Science Conference, ITCS 2021, January 6-8, 2021, Virtual Conference, volume 185 of LIPIcs, pages 57:1–57:20. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPIcs.ITCS.2021.57.
- [74] Shay Solomon and Amitai Uzrad. Dynamic ((1+) ln n)-approximation algorithms for minimum set cover and dominating set. In Barna Saha and Rocco A. Servedio, editors, Proceedings of the 55th Annual ACM Symposium on Theory of Computing, STOC 2023, Orlando, FL, USA, June 20-23, 2023, pages 1187–1200. ACM, 2023. doi:10.1145/3564246.3585211.
- [75] Shay Solomon and Amitai Uzrad. Dynamic set cover with worst-case recourse. CoRR, abs/2511.07354, 2025. doi:10.48550/arXiv.2511.07354.
- [76] Shay Solomon, Amitai Uzrad, and Tianyi Zhang. A lossless deamortization for dynamic greedy set cover. In 65th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2024, Chicago, IL, USA, October 27-30, 2024, pages 264–290. IEEE, 2024. doi:10.1109/FOCS61266.2024.00025.
- [77] Shay Solomon and Nicole Wein. Improved dynamic graph coloring. ACM Trans. Algorithms, 16(3), June 2020. doi:10.1145/3392724.
- [78] Jeffery Westbrook. Load balancing for response time. Journal of Algorithms, 35(1):1–16, 2000. doi:10.1006/jagm.2000.1074.
- [79] Jeffery R. Westbrook and Dicky C. K. Yan. The performance of greedy algorithms for the on-line steiner tree and related problems. Mathematical Systems Theory, 28(5):451–468, 1995. doi:10.1007/BF01185867.
Appendix A The Online (Timed) Gluttonous Algorithm
In this section, we give the formal description of an online simulation of the timed gluttonous algorithm in [55], which is a classic offline Steiner forest algorithm. We can show that it is -competitive.
We can use the same idea as in the proof of Theorem 14 to prove an analogue of Theorem 14: for each level , the number of level- merges times is at most . Therefore, this algorithm is -competitive since the total cost of merges from outside of the top levels is negligible (since each level has at most merges, and the cost per merge decreases exponentially as goes down).
