Temporal Reachability Minimization: Delaying vs. Deleting

We study spreading processes in temporal graphs, i. e., graphs whose connections change over time. These processes naturally model real-world phenomena such as infectious diseases or information flows. More precisely, we investigate how such a spreading process, emerging from a given set of sources, can be contained to a small part of the graph. To this end we consider two ways of modifying the graph, which are (1) deleting connections and (2) delaying connections. We show a close relationship between the two associated problems and give a polynomial time algorithm when the graph has tree structure. For the general version, we consider parameterization by the number of vertices to which the spread is contained. Surprisingly, we prove W[1]-hardness for the deletion variant but fixed-parameter tractability for the delaying variant.


Introduction
Reachability is a fundamental problem in graph theory and algorithmics [38,39,33,17] and quite well-understood. With the emergence of temporal graphs, 1 the concept of reachability was extended to the dimension of time using temporal paths [34,6]. For a vertex s to reach another vertex z in a temporal graph, there must not only be a path between them but the edges of this path have to appear in chronological order. This requirement makes temporal reachability non-symmetric and non-transitive, which stands in contrast to reachability in normal (static) graphs. Reachability is arguably one of the most central concepts in temporal graph algorithmics and has been studied under various aspects, such as path finding [40,5,9,11], vertex separation [34,28,41], finding spanning subgraphs [12,4], temporal graph exploration [25,23,26,7,24,3], and others [35,2,10,32]. 1 Temporal graphs are graphs whose edge set changes over discrete time.
Imaginably, removing edges or vertices is not the most infrastructure friendly approach to restrict reachability. To address this, other operations have been studied. Enright et al. [22] considered restricting the reachability by just changing the relative order in which edges are active. Deligkas and Potapov [15] considered restricting the reachability by a merging operation of consecutive edge sets of the temporal graph and by a delay operation of timeedges by δ time steps, i.e., moving a time-edge from time t to t + δ. In particular, they introduced a delay variant of MinReachDelete.

Input:
A temporal graph G, a set of sources vertices S ⊆ V , and integers k, r, δ. Question: Can we delay at most k time-edges by δ s.t. at most r vertices are reachable from S? This is the central problem studied in this paper. Throughout the whole paper we assume for all instances of MinReachDelete and MinReachDelay that 0 < |S| ≤ r. We remark that technically Deligkas and Potapov [15] formulate the problem slightly differently, allowing delays of up to δ to appear. However, a simple argument can be given to see that this distinction is not significant: Clearly, delaying a time-edge reduces the number of reachable vertices only if the undelayed time-edge could be reached from some source s ∈ S. But when this is the case, increasing the delay of that time-edge can never increase the set of vertices reachable from S. The reason is that, while increasing the delay might enable some source s ′ ∈ S \ {s} to reach a vertex v, that vertex v would be reached from s in any case.
Deligkas and Potapov [15] showed that MinReachDelay is NP-hard and W[1]-hard when parameterized by k, even if underlying graph has lifetime τ = 2. A close look into the proof reveals that this also holds for MinReachDelete.
Our contribution. We study how MinReachDelete and MinReachDelay relate to each other. We show that both problems are polynomial-time solvable on trees. Moreover, there is an intermediate reduction from MinReachDelete to MinReachDelay indicating that MinReachDelay seems generally harder than MinReachDelete. However, surprisingly, this is no longer true when we parameterize the problems by the number r of reachable vertices. Here, we develop a max-flow-based branching strategy and obtain fixed-parameter tractability for MinReachDelay while MinReachDelete remains W[1]-hard. This makes MinReachDelay particularly interesting for applications where the number of reachable vertices should be very small, e.g. when trying to contain the spread of dangerous diseases.
For a function f : V → Z and subset X ⊆ V we denote by f (X) the sum x∈V f (x). We use standard notation from graph theory [16]. We say for a (directed) graph G that is the subgraph when the edges in Y are removed, where X is a vertex set and Y is an edge set. For any predicate P , the Iverson bracket [P ] is 1 if P is true and 0 otherwise. (1) time, where f is any computable function only depending on the parameter. If a parameterized problem L is W[1]-hard, then it is presumably not fixed-parameter tractable. We refer to Downey and Fellows [18] for details.

Temporal graphs.
A temporal graph G consists of a set of vertices V (or V (G)), and a sequence of edge sets (E i ) i∈ [τ ] where each E i is a set of unordered pairs from V . The number τ is called the lifetime of G. The elements of E(G) := i∈[τ ] E i × {i} are called the time-edges of G. Furthermore G has a traversal time function γ : E(G) → N specifying the time it takes to traverse each time-edge. The temporal graph G is then written as the tuple (V, (E i ) i∈ [τ ] , γ). Often we assume γ to be the constant function γ ≡ 1 and then simply write G = (V, (E i ) i∈ [τ ] ). The underlying graph of G is the graph (V, For a time-edge set Y and temporal graph G, we denote by G \ Y the temporal graph forms an s-z-path in the underlying graph of G, and In particular, every vertex reaches itself via a trivial path. Furthermore, w is reachable from S ⊆ V if there is a temporal s-w-path for some s ∈ S, and the set of all vertices reachable from S is denoted the reachable set R G (S). We drop the index G if it is clear form the context. Delaying a time-edge ({v, w}, t) by δ refers to replacing it with the time-edge ({v, w}, t + δ). For a temporal graph G and a time-edge set X ⊆ E(G) we denote by G ↗ δ X the temporal graph G where the time-edges in X are delayed by δ.
) of MinReachDelay such that the feedback vertex number 3 of the underlying graph of G and G ′ is the same, and I is a yes-instance if and only if J is a yes-instance.
) in the following way. Set to G ′ . Afterwards, add the time-edge ({s vu , e vu }, 6τ + 1 = 3τ + δ + 1) for each e vu ∈ V e . Finally we set r ′ := r + |V ′ \ V |. Since we add for each time-edge of G a constant number of vertices and time-edges to G ′ , we have that |G ′ | ∈ O(|G|) and G ′ can be computed in linear time. Moreover, the underlying graph G ′ of G ′ is obtained from the underlying graph G of G by subdividing edges and adding leaves, thus G and G ′ have the same feedback vertex number. It remains to prove that the two instances are equivalent.
(⇒): Let X be a solution for I. Then, set X ′ := {({e vu , e uv }, 3t − 1) | ({v, u}, t) ∈ X}. Pick s ∈ S and v ∈ V arbitrary. Note that for each temporal s-v-path P ′ in G ′ , we can construct a temporal s-v-path P in G which uses a time-edge ({u, w}, t) if and only if P ′ uses the time-edge ({e uw , e wu }, 3t − 1). Furthermore, any temporal s-v-path in G ′ ↗ δ X ′ cannot use any delayed time-edge. As s and v are arbitrary, this proves (⇐): Let X ′ be a solution for J. Begin by observing that delaying any time-edges between V s and V e has no effect. Consequently, R G ′ ↗ δ X ′ (V s ) = V s ∪ V e for every possible choice of X ′ . Therefore X ′ is a valid solution if and only if |R G ′ ↗ δ X ′ (S) ∩ V | ≤ r ′ − |V s ∪ V e | = r, i.e., we only need to study the reachability between vertices in V . Because of this, delaying a time-edge connecting two vertices of V e has the same effect as deleting that time-edge. Next, observe that instead of delaying some time-edge ({v, e vu }, t) which connects vertices of V and V e , the same or better reduction of reachability is achieved by instead delaying ({e vu , e uv }, t ′ ), with t ′ ∈ {t − 1, t + 1} chosen appropriately. Due to this, we may assume without loss of generality that Let s ∈ S and v ∈ V be arbitrary. Note that for each temporal s-v-path P in G, we can construct a temporal s-v-path P ′ in G ′ as above.
Note that the reduction in Lemma 1 preserves the size k of the solution and the feedback vertex number of the underlying graph. We remark that, in exchange for dropping the latter property, one can modify the reduction to instead have |S ′ | = |S|, by simply adding time-edges from S to V s before all other time-edges. However, in any case the size r ′ of the reachable set in J is unbounded in terms of the size r of the reachable set in I. Unless FPT = W [1], this is unavoidable as we learn in the next section.

Parameterized by the Reachable Set Size
In this section the study MinReachDelay and MinReachDelete parameterized by the reachable set size r. In particular, our main result in this section is the fixed-parameter tractability of MinReachDelay parameterized by r. This is in stark contrast to the W[1]-hardness of MinReachDelete parameterized by r which we show first.
Proof. We present a parameterized reduction from the W[1]-hard [18] Clique problem parameterized by ℓ, where given a graph H = (U, F ) we are asked whether H contains a clique of size ℓ. [2] ) is the temporal graph given by Note that I can be constructed in polynomial time.
be a solution for I. Without loss of generality, we can assume that X does not contain a time-edge ({e f , u}, 2), because it can be replaced by ({e f , s}, 1). Observe that at least ℓ 2 vertices from {e f | f ∈ F } are reachable from s in G \ X. Since r = 1 + ℓ 2 + ℓ, we can reach from s at most ℓ vertices from U . Hence, U ∩ R G\X ({s}) must form a clique of size ℓ in H. ◀ Due to Theorem 2, we know that there is presumably no f (r) · |G| O(1) -time algorithm to decide whether we can keep the reachable set of a vertex s of G small (at most r vertices), by deleting at most k time-edges. However, this changes when we delay (instead of deleting) at most k edges. Formally, we show the following.
The proof of Theorem 3 is structured as follows.
Step 1 (reduction to slowing): We reduce MinReachDelay to an auxiliary problem which we call MinReachSlow. Here, instead of delaying a time-edge (moving it δ layers forward in time) we slow it, i. e., increase the time required to traverse it by δ.

Step 2 (flow-based techniques): Our new target now is a fixed-parameter algorithm for
MinReachSlow. Since we do not aim to preserve a specific temporal graph class, we simplify the input by replacing S with a single-source s. Then we transform the temporal graph G into a (non-temporal) directed graph D in which the deletion of an edge corresponds to slowing a temporal edge in G. Using this, we derive a max-flow-based polynomial-time algorithm which checks whether the source s can be prevented from reaching any vertices outside of a given set R by slowing at most k time-edges in G.

76:6
Temporal Reachability Minimization: Delaying vs. Deleting Step 3 (resulting search-tree) : We are aiming for a search-tree algorithm for MinReach-Slow. Let R be a set of vertices and suppose that our max-flow-based algorithm failed to prevent s from reaching any vertices outside of R. Now, if there exists a solution for the given instance of MinReachSlow, then we can identify less than |R| vertices such that at least one of them will be always reached from s. We can then try adding each of them to R, gradually building a search-tree to find the solution.
Henceforth the details follow. Instead of solving MinReachDelay directly, we reduce it to an auxiliary problem introduced next.
. Our auxiliary problem is the following.
Minimizing Temporal Reachablity by Slowing (MinReachSlow) , γ), a set of sources S ⊆ V , and integers k, r, δ. Question: Is there a time-edge set X ⊆ E(G) of size at most k such that |R G↑ δ X (S)| ≤ r? By the following, solving an instance of MinReachSlow also solves MinReachDelay.
(⇐): Let X ⊆ E(G) be an inclusion-minimal solution for J. We claim that every vertex reachable from S in G ↗ δ X by some time t is also reachable from S in G ↑ δ X until time t. Suppose for contradiction that the claim does not hold true for some vertex z and let t be the time S reaches z in G ↗ δ X. We may assume z to be chosen to minimize t. Clearly t > 0, i. e., z / ∈ S. Let P be a temporal s-z-path in G ↗ δ X with arrival time t and s ∈ S. Let u be the penultimate vertex of P and ({u, z}, t ′ ) the last time-edge of P . By minimality of t, u must be reachable from S by time t ′ also in G ↑ δ X. Since all time-edges of E(G) \ X appear in G ↗ δ X and G ↑ δ X with identical traversal times, the last time-edge ({u, z}, t ′ ) of P must be in E(G ↗ δ X) \ (E(G) \ X). Thus ({u, z}, t ′ − δ) ∈ X. By minimality of X, there must be a source s ′ ∈ S and a temporal s ′ -u-path P ′ in G ↑ δ X reaching either u or z at time t ′ − δ. If P ′ reaches z, then this is clearly a contradiction. But if P ′ reaches u, then appending ({u, z}, t − δ) to P ′ produces a temporal s ′ -z-path in G ↑ δ X arriving at time t, thus also a contradiction. ◀ In the reminder of this section, we show that MinReachSlow is fixed-parameter tractable, when parameterized by r. Formally, we aim for the following theorem, which in turn clearly implies Theorem 3 by the means of Lemma 4. The remainder of this section is dedicated to proving Theorem 5. The advantage of considering MinReachSlow instead of MinReachDelay is that we do not have to deal with new time-edges appearing due to the delay operation. This allows us to translate the reachability of a temporal graph to a (non-temporal) directed graph specially tailored to MinReachSlow.
In particular, the removal of some edges in the directed graph corresponds to slowing the corresponding time-edges by δ in the temporal graph. Before giving the details of the construction, we first reduce to the case where S is a singleton. S, k, r, δ) of MinReachSlow, we can construct in linear time a instance J = (G ′ , {s}, k, r + 1, δ) of MinReachSlow such that I is a yes-instance if and only if J is a yes-instance.

▶ Lemma 6. Given an instance
Observe that slowing an edge in E ′ 1 has no effect. Thus, I is a yes-instance if and only if J is a yes-instance. Clearly, J can be computed in linear time.  and (v t , e 1 ), (w t , e 1 ), (e 1 , e 2 ), (e 2 , v t+γ(e) ), (e 2 , w t+γ(e) ), (v t , w t+γ(e)+δ ), (w t , v t+γ(e)+δ ) v, w ∈ R and e = ({v, w}, t) ∈ E(G) and we set c((e 1 , e 2 )) = 1 for all e ∈ E(G) and c(a) = ∞ for all other a ∈ A. Consider Figure 1 for an illustration.   1)). Afterwards, the currently last vertex ofP is v b .

(⇒):
Let P be a s 0 -x t -path in (V ′ , A \ C). Then we construct a s-x-path P ′ with arrival time at most t in G ↑ δ X as follows. Start with P ′ being just the vertex s (with arrival time 0) and repeat the following steps until all arcs of P have been processed. 1. Let b be the arrival time of P ′ and v the last vertex. Note that the last vertex of P is v c for some c ≥ b. Ignore all arcs of P up to the last arc containing v c for some c ≥ b.

2.
If the next three arcs in P are (v c , e 1 ), (e 1 , e 2 ), (e 2 , w c+γ(e) ) for some time-edge e = ({v, w}, c) ∈ E(G), then append to P ′ that time-edge e. Note that, by assumption, (e 1 , e 2 ) / ∈ C, thus e / ∈ X, and thus the arrival time of e is c + γ ′ (e) = c + γ(e). 3. Otherwise the next arc in P must be (v c , w c+γ(e)+δ ) for some time-edge e = ({v, w}, c) ∈ E(G). Then append to P ′ that time-edge e. Note that the arrival time of e is c + γ ′ (e) ≤ c + γ(e) + δ. ◀ We now show that we can use Lemma 7 to check whether s can be prevented from reaching any vertices outside of R by slowing at most k time-edges by δ each. (⇒): Let the maximum s 0 -z-flow f in F have value at most k. Moreover, let C be a s 0 -z-cut of minimum capacity. From the max-flow min-cut theorem [30], we know that c(C) ≤ k. Note that C ⊆ {(e 1 , e 2 ) ∈ A | e ∈ E(G)}, since all other edges have infinite capacity. Hence, |C| ≤ k. Now set X := {e ∈ E(G) | (e 1 , e 2 ) ∈ C}. Assume towards a contradiction that there is a temporal s-x-path P in G ↑ δ X for some x ∈ V \ R. We may take P to be minimal, thus the penultimate vertex y of P is contained in R. By Lemma 8 there is a s 0 -y t -pathP in (V ′ , A \ C) where t is the time P reaches y. The fact that P afterwards proceeds to x and (3) in the definition of F imply that (V ′ , A \ C) contains a path from y t to z. This contradicts C being a s 0 -z-cut in (V ′ , A).
(⇐): Let X be a time-edge set as assumed. By assumption R G↑ δ X ({s}) ⊆ R. We claim that C = {(e 1 , e 2 ) | e ∈ X} ⊆ A is a s 0 -z-cut in (V ′ , A), which implies that the maximum value of an s 0 -z-flow in F is at most c(C) ≤ k [30]. So suppose towards a contradiction that there is a s 0 -z-path P in (V ′ , A \ C). Let x t ∈ V be the penultimate vertex of P . Then there is a s-x-path P ′ in G ↑ δ X with arrival time at most t by Lemma 8. The final arc of P is (x t , z). Hence, (x t , z) must be contained in (3), i. e., we can extend P ′ by some time-edge to end at a vertex in V \ R. This contradicts our assumption s, R, δ) contains a s 0 -z-flow of value k + 1, then we want to find a small set Y ⊆ s, R, δ). We may assume f to never use an arc (v t , w t ′ ) whenever A contains some arc (v b , z) with b ≥ t, as we could otherwise redirect f to use that latter arc (of infinite capacity) instead. Note that performing this modification can be done in O(k · |A|) time. Now set By (3), we have |H| ≤ |R| and N G (v, t) \ R ̸ = ∅ for all (v, t) ∈ H. Construct the vertex set Y by picking for each (v, t) ∈ H one arbitrary vertex from N G (v, t) \ R. Hence |Y | ≤ |H| ≤ |R| and Y ∩ R = ∅.
It remains to prove that R G↑ δ X (s) ∩ Y ̸ = ∅, with X ⊆ E(G) being an arbitrary solution for the MinReachSlow-instance (G, {s}, k, r, δ). Define C := {(e 1 , e 2 ) ∈ A | e ∈ X}. Since f has value k + 1 > c(C), there is a s 0 -v t -path P in (V ′ , A \ C) where each edge e ∈ E(P ) has f (e) > 0 and (v, t) ∈ H. By Lemma 8, there is a temporal s-v-path P ′ in G ↑ δ X with arrival time at most t. Note that through P ′ , vertex s can reach v as well as all vertices of Let I be a yes-instance. Thus there is a set X of at most k time-edges such that |R G↑ δ X (s)| ≤ r. We claim that g(R ′ ) returns yes for all R ′ with s ∈ R ′ ⊆ R G↑ δ X (s). We prove this by reverse induction on |R ′ |. In the base case where R = R G↑ δ X (s), g(R) returns yes by Lemma 9. Now assume the claim to hold whenever |R| = q and let R be of size q − 1 with s ∈ R ⊆ R G↑ δ X (s). Assume that F(G, s, R, k, δ) has a s 0 -z-flow of value k + 1, otherwise we are done (by line 4). By Lemma 10, the set Y computed in line 6 contains a vertex u ∈ R G↑ δ X (s) \ R. Thus, g(R ∪ {u}) returns yes by induction hypothesis. Hence, by line 8, g(R) return yes, completing the induction. In particular, g({s}) returns yes, therefore Algorithm 11 is correct.
To bound the running time, note that each call g(R) makes at most |Y | ≤ |R| recursive calls by Lemma 10. In each of these recursive calls the cardinality of R increases by one until |R| = r, so the recursion depth is at most r by line 5. Hence, we can observe by an inductive argument that the search tree has d! many nodes at depth d, where the root is at depth 1. Hence, the search tree has at most r! many leaves and thus O(r!) many nodes in total. By Lemma 7 and Lemma 10, lines 3 and 6 take at most O(k · |G|) time. Hence, the overall running time is bounded by O(r! · k · |G|). ◀

A Polynomial-Time Algorithm for Forests
In this section we present an algorithm that solves MinReachDelete and MinReachDelay in polynomial time on temporal graphs where the underlying graph is a tree or a forest. This is a quite severe yet well-motivated restriction of the input [20,22,21], since it could serve as the starting point for FPT-algorithms for "distance-to-forest"-parameterizations. Actually we even provide an polynomial-time algorithm for a generalized version of Min-ReachDelay. Then, polynomial-time solvability of MinReachDelete follows from Lemma 1, since it is forest preserving. We define the generalized problem as follows:

Input:
A temporal graph G = (V, (Ei) i∈ [τ ] , γ) whose underlying graph is a forest, a weight function w : V → N ∪ {0, ∞}, a set F ⊆ E(G) of undelayable time-edges, a set of sources S ⊆ V , and integers k, r, δ. Question: Does there exists a time-edge set X ⊆ E(G) \ F of size at most k such that w(R G↗ δ X (S)) ≤ r?
In the remainder of this section, we show how to solve this problem using dynamic programming in polynomial time. Informally speaking, our dynamic program works as follows. As a preprocessing step we unfold vertices of large degree, reducing to an equivalent instance of maximum degree 3. Then we root each underlying tree at an arbitrary vertex and build a dynamic programming table, starting at the leaves. More precisely, we compute a table entry for each combination of a vertex v, a budget k, a time step t, and a flag indicating whether v is first reached from a child or from its parent. This table entry then contains a minimum reachable subset of the subtree rooted at v that can be achieved by applying k delay operations to that subtree.

▶ Theorem 13. Weighted MinReachDelay on Forests is polynomial-time solvable if the underlying graph is a forest.
Proof. Assume for now that the underlying graph of G is a tree, rooted at an arbitrary leaf. We denote by T v the subtree with root v ∈ V . We use the reaching time ∞ to denote "never". By convention, a vertex can reach itself at time 0. Define N * := N ∪ {0, ∞}.
We first show how to transform the underlying graph into a binary tree. This will highly simplify the description of the dynamic programming table. Replace each vertex v of degree deg(v) > 3 by a path on deg(v) − 2 new vertices, where each edge of that path is undelayable, appears at each time step and always has traversal time 0. Distribute the edges formerly incident to v among the new vertices such that each of them has degree 3. Set the weight of the path's first vertex to the weight of v, and the weight of all other path vertices to 0. Note that this modification produces an equivalent instance of maximum degree at most 3, while increasing the number of vertices only by a constant factor.
We extend the notion of reachability to vertex-time pairs (s, t) ∈ S × [τ ] by saying that (s, t) reaches v ∈ V in G if there exists a temporal s-v-path starting at time t or later. For a set A ⊆ V × [τ ], R G (A) is the set of all vertices, reachable from any member of A in G. We say a vertex v is reached through another vertex w if there is a temporal path from a source s ∈ S to v that uses w.
Let v ∈ V , k ∈ N. Define T v,k as the set of temporal graphs obtained from T v by applying up to k delay operations. Partition where the minimum of an empty set is ∞ by convention. It is convenient to also define these entries as ∞ whenever k < 0. Roughly speaking, D[v, k, t, ι] contains the minimal weight reached in T v under the assumption that up to k delay operations are applied to T v , that v is first reached at time t, and that v is reached by a source in S ∩ V (T v ) at time t if ι = false, v is reached by a source in S \ V (T v ) at time t if ι = true. Note that v might be reached simultaneously from S ∩ V (T v ) and S \ V (T v ). We next show how to compute D [v, k, t, ι] recursively, starting at the leaf vertices. Observe that D[v, k, t, ι] = ∞ whenever v ∈ S is a source and t > 0. Thus, this case shall be excluded in the following.
If v has no children. If ι = false and v / ∈ S and t < ∞, then D[v, k, t, false] = ∞ as there is no way that v can be reached from a source in S ∩ V (T v ) = ∅. Otherwise, If v has exactly one child v ′ . If ι = false and v / ∈ S, then v must be reached through v ′ at time t. In this case the minimal total weight reached in T v ′ is where κ(t ′ , t) is the minimal number of delays that need to occur on the edge {v, v ′ } to ensure that (v ′ , t ′ ) reaches v at time t but not earlier.
If ι = true or v ∈ S, then there are two possibilities. If v ′ is reached through v at time t ′ , with t ′ being the first time v ′ is reached from S, then the minimal total weight reached in Otherwise, v ′ must be reached from a source in S ∩ V (T v ′ ) at time t ′ , thus the minimal total weight reached in T ′ v is whereκ(t ′ , t) is the minimal number of delays that need to occur on {v, v ′ } to ensure that (v, t) cannot reach v ′ before time t ′ and (v ′ , t ′ ) cannot reach v before time t. (Again, set κ(t ′ , t) = ∞ if this is impossible.) Thus we obtain for the case that ι = true or v ∈ S that If v has two children v ′ , v ′′ . The situation is similar to that of only one child vertex, although more possible cases have to be distinguished. We omit the tedious details. However, it is clear that D[v, k, t, ι] can be computed by simply trying all possible tuples (t ′ , t ′′ , k ′ , k ′′ , i ′ , i ′′ , ι ′ , ι ′′ ) where t ′ , t ′′ are the times at which v ′ , v ′′ are reached; k ′ , k ′′ are the number of delays occurring in T v ′ , T v ′′ ; i ′ , i ′′ are the number of delays occurring on the edges {v, v ′ }, {v, v ′′ }; and ι ′ , ι ′′ describe whether v ′ , v ′′ are reached from a source in their respective subtrees at time t ′ and t ′′ , respectively. The number of such tuples and the time required to process each of them is clearly polynomial in t + k + |G|. It remains to consider the case that the underlying graph of G is a disconnected forest. In this case simply apply the above algorithm to each connected component. Afterwards, determining the optimal way to split the overall budget between the connected components can be computed by a simple dynamic program. Define X[i, k] as the minimum weight reached in the first i trees if up to k time-edges are delayed and use the fact that and for all i > 1 wherev j is the root of the j th tree. ◀

Conclusion
While both problem variants, MinReachDelete and MinReachDelay, are polynomialtime solvable on forests and W[1]-hard when parameterized by k, even if the lifetime is τ = 2, their complexities diverge when we parameterize by the number r of reachable vertices. Here, MinReachDelete is W[1]-hard while for MinReachDelay we found a fixed-parameter tractable algorithm. This makes MinReachDelay particularly interesting for applications where the number of reachable vertices should be very small, e.g. when trying to contain the spread of dangerous diseases.
On the practical side we want to point out that our algorithm for MinReachDelay parameterized by r uses only linear space, and its search-tree-based approach makes it fit for optimization techniques like further data reduction rules or pruning using lower bounds. Furthermore, our max-flow-based branching technique can be turned into a r-approximation for for minimizing the number r of reachable vertices by delaying k time-edges. To do so, instead of branching into all choices of v ∈ Y in line 8 of Algorithm 11, simply invoke g(R ∪ Y ). Refining the presented technique towards better approximation guarantees seems to be a promising research direction. Moreover, when focusing on specific applications, it is natural to exploit application-dependent graph properties towards designing more efficient algorithms. In particular: which well-motivated temporal graph classes beyond trees allow e.g. polynomial-time solvability of MinReachDelete or MinReachDelay? Finally, from the viewpoint of parameterized complexity the parameters k and r are settled, but the landscape of structural parameters is still waiting to be explored.