Abstract 1 Introduction 2 Preliminaries 3 NP-Hardness Results 4 The Influence of Membership-Width Based Parameters 5 Complexity with respect to Input Parameters 6 Conclusion References

Timeline Problems in Temporal Graphs:
Vertex Cover vs. Dominating Set

Anton Herrmann ORCID Algorithmics and Computational Complexity, Technische Universität Berlin, Germany Christian Komusiewicz ORCID Institute of Computer Science, Friedrich Schiller University Jena, Germany Nils Morawietz ORCID Institute of Computer Science, Friedrich Schiller University Jena, Germany
LaBRI, Université de Bordeaux, Talence, France
Frank Sommer ORCID Institute of Logic and Computation, TU Wien, Austria
Institute of Computer Science, Friedrich Schiller University Jena, Germany
Abstract

A temporal graph is a finite sequence of graphs, called snapshots, over the same vertex set. Many temporal graph problems turn out to be much more difficult than their static counterparts. One such problem is Timeline Vertex Cover (also known as MinTimeline), a temporal analogue to the classical Vertex Cover problem. In this problem, one is given a temporal graph 𝒢 and two integers k and , and the goal is to cover each edge of each snapshot by selecting for each vertex at most k activity intervals of length at most each. Here, an edge uv in the ith snapshot is covered, if an activity interval of u or v is active at time i. In this work, we continue the algorithmic study of Timeline Vertex Cover and introduce the Timeline Dominating Set problem where we want to dominate all vertices in each snapshot by the selected activity intervals.

We analyze both problems from a classical and parameterized point of view and also consider partial problem versions, where the goal is to cover (dominate) at least t edges (vertices) of the snapshots. With respect to the parameterized complexity, we consider the temporal graph parameters vertex-interval-membership-width (vimw) and interval-membership-width (imw). We show that all considered problems admit FPT-algorithms when parameterized by vimw+k+. This provides a smaller parameter combination than the ones used for previously known FPT-algorithms for Timeline Vertex Cover. Surprisingly, for imw+k+, Timeline Dominating Set turns out to be easier than Timeline Vertex Cover, by also admitting an FPT-algorithm, whereas the vertex cover version is NP-hard even if imw+k+ is constant. We also consider parameterization by combinations of n, the vertex set size, with k or and parameterization by t. Here, we show for example that both partial problems are fixed-parameter tractable for t which significantly improves and generalizes a previous result for a special case of Partial Timeline Vertex Cover with k=1.

Keywords and phrases:
NP-hard problem, FPT-algorithm, interval-membership-width, Color coding
Funding:
Nils Morawietz: Supported by the French ANR, project ANR-22-CE48-0001 (TEMPOGRAL).
Frank Sommer: Supported by the Alexander von Humboldt Foundation.
Copyright and License:
[Uncaptioned image] © Anton Herrmann, Christian Komusiewicz, Nils Morawietz, and Frank Sommer; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Parameterized complexity and exact algorithms
; Theory of computation Graph algorithms analysis
Related Version:
Some of the results of this work are also contained in the first author’s Master’s thesis [21].
Editors:
Akanksha Agrawal and Erik Jan van Leeuwen

1 Introduction

A crucial task in the management of wireless sensor networks is to monitor the network by selecting few dedicated sensors that can monitor themselves and other sensors which are close enough to have a direct wireless connection [27, 30]. In graph-theoretic terms, this is the famous NP-hard Dominating Set problem where we say that a vertex dominates itself and all its neighbors and the task is to select few vertices of the graph such that every vertex is dominated by some selected vertex. In some applications of sensor networks, the network may change over time. Then, instead of a static graph G the input would be a temporal graph 𝒢, consisting of a set of snapshots Gi, each reflecting the connections at timestep i. Moreover, in such a scenario each sensor could carry out the surveillance only for a bounded duration, for example due to limited battery capacities. Thus, instead of selecting few sensors to monitor the network, we would like to select, for each sensor, an active time interval of bounded length , during which it monitors itself and all its current neighbors. To make the model more general, we may also allow for each sensor to select up to k such active intervals, for example because each sensor carries k batteries. By calling a collection of active intervals for all vertices of the graph a k-activity -timeline, the scenario described above corresponds to the following problem.

Timeline Dominating Set (Timeline DS)
Input: A temporal graph 𝒢 and integers k1,0.
Question: Is there a k-activity -timeline 𝒯 which dominates all temporal vertices of 𝒢?

For an example input and solution for Timeline DS, refer to Figure 1. As in the static Dominating Set problem, we may further generalize the problem to handle scenarios where we are not able to monitor the whole network over the full time period but instead we want to maximize the number of monitored sensors under the resource limitations.

Timeline Partial Dominating Set (Timeline PDS)
Input: A temporal graph 𝒢 and integers k1,0,t0.
Question: Is there a k-activity -timeline 𝒯 which dominates at least t temporal vertices of 𝒢?

In this work, we initialize the study of Timeline (Partial) Dominating Set in particular from a computational complexity perspective. As we show, Timeline (Partial) Dominating Set is NP-hard. To cope with this intractability, we consider mostly the parameterized complexity of the problem, with a particular focus on structural parameterizations of temporal graphs.

The idea to consider timelines in a temporal graph setting is not new: Rozenshtein et al. [28] introduced it in Timeline Vertex Cover,111Rozenshtein et al. denote this problem as MinTimeline. the second main problem studied in this work.

Timeline Vertex Cover (Timeline VC)
Input: A temporal graph 𝒢 and integers k1,0.
Question: Is there a k-activity -timeline 𝒯 which covers all temporal edges of 𝒢?

For an example input and solution for Timeline VC, refer again to Figure 1. The model behind Timeline VC is that edges in a temporal graph arise only when at least one of their endpoints is active and the task of the problem is to provide an explanation of all edges such that the vertices are only active a few times, each time only for a short duration [28].

Figure 1: The short red boxes represent a 2-activity 0-timeline dominating all temporal vertices and the long blue boxes represent a 1-activity 2-timeline covering all temporal edges. Observe that the interval length is defined in such a way that an interval starting and ending in the same snapshot has length 0.

Dondi et al. [12] later analyzed the partial variant of the problem.

Timeline Partial Vertex Cover (Timeline PVC)
Input: A temporal graph 𝒢 and integers k1,0,t0.
Question: Is there a k-activity -timeline 𝒯 which covers at least t temporal edges of 𝒢?

We continue the study of Timeline (Partial) Vertex Cover with two aims: First, some of the parameters considered in our study have not yet been studied for this problem. Second, we seek a comprehensive complexity overview for these two fundamental timeline problems, highlighting their similarities and differences.

Previous results.

Rozenshtein et al. [28] showed that Timeline VC is NP-hard in general, but solvable in polynomial time for k=1. Froese et al. [18] continued the algorithmic study of Timeline VC. They proved NP-hardness even if the input consists of at most three snapshots, k=2 and =0 and studied the parameterized complexity with respect to different parameters. Froese et al. [18] showed fixed-parameter tractability for n+k and W[1]-hardness for n+. Herein, n is the number of vertices of the underlying graph which in turn is the static graph obtained by taking the union of all edge sets. Moreover, Timeline VC admits an XP-algorithm for n and is fixed-parameter tractable with respect to n if =0 [18]. Schubert [29] later analyzed the parameterized complexity of Timeline VC with respect to combinations of input parameters with structural parameters of the underlying graph. Finally, Dondi et al. [12] obtained two results for Timeline PVC with k=1: First, it was shown that this case is NP-hard, in contrast to Timeline VC. Second, Dondi et al. [12] gave FPT-algorithms for parameterization by the number of covered edges and by the number of uncovered edges.

Our results.

We start off with a new hardness result for Timeline VC: We show that the problem remains NP-hard even if the total number of snapshots T, k, and are constant and additionally the maximum degree in every snapshot is at most one. Then, we show the NP-hardness of Timeline DS, again for the case that T, k, and are constant and the maximum snapshot degree is one.

We then study the parameterized complexity of the problems; an overview of the results is given in Table 1. As noted above, Timeline VC is fixed-parameter tractable with respect to n+k [18]. Since n is a rather large parameter, Froese et al. [18] asked whether there are FPT-algorithms also for parameters that are smaller than n. We make progress in this direction by considering the two parameters interval-membership-width (imw) and vertex-interval-membership-width (vimw) which where introduced by Bumpus and Meeks [3]. The parameters imw and vimw are interesting in the sense that they are among the relatively few truly temporal structural graph parameters because they are sensitive to the order of the snapshots [3]. Informally, vimw can be defined as follows: We say the lifetime of a vertex is the time interval between its first and last non-isolated appearance in a snapshot. For a timestep i, the bag of i is the set of vertices whose lifetime contains timestep i, and vimw is the size of the largest bag of 𝒢.

We first show that Timeline PVC is fixed-parameter tractable with respect to vimw+k+. To further improve on this, we introduce a hierarchy of parameters with non-increasing size. The idea, inspired by the h-index of static graphs [16], is that a temporal graph may have only few large bags. In that case, we would rather parameterize by the size of the xth largest bag, denoted by vimw[x], for some x>1. With this definition, we have vimw=vimw[1] and vimw[x]vimw[x+1] for all x[T]. We show that Timeline PVC is fixed-parameter tractable for vimw[x]+k+ with x=k(+1). Informally, this means that the larger k and get, the more large bags can be ignored for the parameter. We then consider Timeline (Partial) Dominating Set in the same setting. We first showing fixed-parameter tractability of Timeline PDS for vimw+k+. Then we show that for Timeline DS it can be improved to fixed-parameter tractability for vimw[x]+k+ for x=+2 while for Timeline PDS parameterization by vimw[2]+k+ is not useful. The latter result is obtained by showing NP-hardness of the extremely restricted special case when there are two snapshots, one of which is edgeless, k=1 and =0.

Afterwards, we consider the interval-membership-width (imw). Informally, this is the edge-version of vimw, that is, the bag at timestep i contains the edges which occur at timestep i and those that occur both before and after i. Note that imw can be considered to be a smaller parameter than vimw: For all instances, we have vimwΩ(imw) and there are instances with constant values of imw and unbounded values of vimw. We show that Timeline DS is fixed-parameter tractable for the parameter imw+k+ while all three other problems are NP-hard for constant values of imw+k+. Given the latter hardness results, we refrain from analyzing a hierarchy of imw-based parameters. Altogether, the results show that in our setting, vimw is a much more powerful parameter than imw.

We then conclude by considering the more standard parameters n, k, , and t, where t denotes the number of vertices to dominate or edges to cover, respectively. For Timeline DS, we show fixed-parameter tractability for n+k and W[1]-hardness for n+, thus showing that the complexity is similar to the one of Timeline VC. Finally, we show that Timeline PDS and Timeline PVC can be solved in 2𝒪(t)(n+T)𝒪(1) time. This improves and extends a previous result of Dondi et al. [12, Thm. 6] who provided an algorithm for Timeline PVC with k=1 that has running time 2tlog(t)(n+T)𝒪(1)=tt(n+T)𝒪(1).

Proofs of statements marked with () are deferred to the related full version.

Table 1: Overview of our results on the classic and parameterized complexity for Timeline (Partial) Vertex Cover and Timeline (Partial) Dominating Set. Herein, vimw denotes the vertex-interval-membership-width, imw denotes the interval-membership-width, and vimw[x] denotes the size of the x-largest bag in the vertex-interval-membership sequence. Recall that vimw=vimw[1].
Parameter Timeline VC Timeline PVC Timeline DS Timeline PDS
vimw+k+ FPT FPT FPT FPT
Thm. 4.1 Thm. 4.1 Thm. 4.3 Thm. 4.3
imw+k+ NP-h NP-h FPT NP-h
Thm. 4.7 Thm. 4.7 Thm. 4.6 Thm. 4.8
k++vimw[x] x=k(+1)+1 x=k(+1)+1 x=+2 x=2
FPT FPT FPT NP-h
Prop. 4.2 Prop. 4.2 Prop. 4.4 Thm. 4.5
n+k FPT ? FPT ?
[18, Thm. 8] Thm. 5.1
n+ W[1]-h W[1]-h W[1]-h W[1]-h
[18, Thm. 12] [18, Thm. 12] Thm. 5.2 Thm. 5.2
t FPT FPT
Thm. 5.4 Thm. 5.4

Further related work.

Akrida et al. [1] introduced the problems Temporal Vertex Cover (TVC) and Sliding Window Temporal Vertex Cover (SW-TVC), where the goal is to find a minimum number of temporal vertices that cover the edges of the temporal graph. In TVC each edge needs to be covered in at least one of the snapshots and in SW-TVC, the input contains an integer Δ, and the aim is to cover every edge at least once at every Δ consecutive time steps. Akrida et al. [1] showed that TVC remains NP-hard when the underlying graph is a star graph. Moreover, they studied the approximability of both problems, provided (S)ETH-based running time lower bounds and designed an exact dynamic programming algorithm with exponential running time. The research on these problems was then continued by Hamm et al. [20], who showed that TVC is solvable in polynomial time if the underlying graph is a path or cycle while SW-TVC remains NP-hard in this case. Besides that, they provided several (exact and approximation) algorithms for the sliding window variant. The Temporal Dominating Set (TDS) problem is defined analogously, here the task is to dominate every vertex in at least one of the snapshots of the temporal graph by selecting few temporal vertices. TDS is NP-hard in very restricted cases, for example when the maximum degree in every snapshot is 2 [22]. There are further temporal variants of Vertex Cover and Dominating Set which have been discussed and studied. These include a multistage variant of Vertex Cover [17], a reachability-based variant for Dominating Set [23] and different conditions on how and when a vertex should be dominated [4, 31].

2 Preliminaries

We denote the set of integers {i,i+1,,j1,j} by [i,j], and [1,i] simply by [i]. Given a set V and an integer k>0, we write (Vk) for the collection of all size-k subsets of V.

Graph theory.

A (static) graph G=(V,E) consists of a set of vertices V and a set of edges E(V2). We denote by V(G) and E(G) the vertex and edge set of G, respectively. Furthermore, we let n:=|V(G)| and m:=|E(G)|. For an edge {u,v} we write uv and call u and v endpoints of the edge. Further, we say that the vertex vV is incident with eE if ve. If uvE, then u and v are adjacent and they are neighbors of each other. The set NG(v):={uV:u and v are adjacent} is the (open) neighborhood of v. Moreover, NG[v]:=NG(v){v} is the closed neighborhood of v. For a set of vertices S, we let NG[S]:=sSNG[s] and NG(S)=NG[S]S. By degG(v):=|NG(v)| we denote the degree of v. If degG(v)=0, we say that v is isolated. The maximum degree is Δ(G):=maxvVdegG(v). For vertex sets S and T, we let EG(S,T):={uvE(G):uS and vT} and we let E(S):=E(S,S). A graph G is bipartite if V(G) can be partitioned into two sets S and T such that E(G)=E(S,T). For more details on graph theory, we refer to the book by Diestel [8].

Temporal graphs.

A temporal graph 𝒢 is a finite sequence of graphs (G1,,GT) which all have the same set of vertices V(𝒢):=V(G1)==V(GT). The graphs Gi are called snapshots, T is the lifetime of 𝒢, and i[T] is a time step. We may write V instead of V(𝒢) and Ei instead of E(Gi). Moreover, for u,vV and i[T], (v,i) is a temporal vertex and ({u,v},i)=(uv,i) with uvEi is a temporal edge in snapshot Gi. We say edge e appears in Gi if eEi. Moreover, we say that a vertex v is incident with the temporal edge (e,i) if ve. For a temporal vertex (v,i), we define the (open) neighborhood by N𝒢((v,i)):=NGi(v) and the closed neighborhood by N𝒢[(v,i)]:=NGi[v]. By G(𝒢):=(V:=V(𝒢),E:=i=1TEi) we denote the underlying graph of 𝒢. We let Δi(𝒢)=Δ(Gi). Furthermore, by Δmax(𝒢):=maxi=1TΔi(𝒢) we denote the maximum snapshot degree of 𝒢. If Ei= we say that Gi is empty. We may drop the subscript 𝒢 when it is clear from context.

Parameter definitions.

We give the precise definitions of the parameters related to the (vertex)-interval-membership width: vimw, vimw[x], and imw.

Let 𝒢=(G1,,GT) be a temporal graph. The vertex-interval-membership sequence of 𝒢 is the sequence (Fi)i[T] of vertex-subsets FiV(𝒢) (called bags), where each Fi is defined as

Fi:={vV(𝒢):p,q[T] such that piq,degGp(v)1 and degGq(v)1}.

The vertex-interval-membership-width of 𝒢, denoted by vimw(𝒢), is the maximum size of a bag in the vertex-interval-membership sequence, that is, vimw(𝒢):=max{|Fi|:i[T]}.

For given x[T] we introduce the parameter vimw[x] as the size of the xth largest bag of the vertex-interval-membership sequence. Formally, let (Fi1,,FiT) be an ordering of (Fi)i[T] such that |Fi1||FiT|. Then we define

vimw[x](𝒢):=|Fix|.

Note that vimw[i] can be much smaller than vimw[1]=vimw: for example consider a temporal graph where every vertex only appears non-isolated for a short period of time. If all snapshots have only a few edges, then vimw is small. However, a single snapshot with many edges is enough to make vimw arbitrarily large. If only a few such snapshots exist, then vimw[i] is already much smaller then vimw for small i.

The interval-membership sequence of 𝒢 is the sequence (Fi)i[T] of edge-subsets FiE (again called bags), where each Fi is defined as

Fi:={eE:p,q[T] such that piq and eEpEq}.

The interval-membership-width of 𝒢, denoted by imw(𝒢), is the maximum size of a bag in the interval-membership sequence, that is, imw(𝒢):=max{|Fi|:i[T]}.

We remark that vimw=Ω(imw) and that there exist temporal graphs with imw=1 but arbitrary large vimw [3]. Finally, note that the vertex-interval-membership sequence and the interval-membership sequence can be computed in polynomial time with respect to the input size.

Timelines.

Given a temporal graph 𝒢=(G1,,GT), an activity interval of a vertex v is a triple (v,a,b)V(𝒢)×[T]×[T] such that ab. We say a that is the starting time and b is the end time of an activity interval (v,a,b). The length of the activity interval is defined by ba. A k-activity timeline of the temporal graph 𝒢 is a set of activity intervals 𝒯{(v,a,b)V(𝒢)×[T]×[T]:ab}, which contains at most k activity intervals for each vertex. A k-activity -timeline is a k-activity timeline in which each activity interval has length at most . Given a k-activity timeline 𝒯, a vertex v is called active in snapshot Gi, if there exists (v,a,b)𝒯 such that aib. A k-activity timeline 𝒯 dominates the temporal vertex (v,i) if vNGi[{u:u is active in Gi}]. A k-activity timeline 𝒯 covers the temporal edge (e,i) if at least one of the two endpoints of e is active in snapshot Gi.

Parameterized complexity.

Let LΣ be a computational problem specified over some alphabet Σ and let p:Σ be a parameter, that is, p assigns to each instance of L an integer parameter value (which we simply denote by p if the instance is clear from the context). We say that L is fixed-parameter tractable (FPT) with respect to p if L can be decided in f(p)|I|𝒪(1) time where |I| is the length of the input. The corresponding hardness concept related to fixed-parameter tractability is W[t]-hardness, t1; if a problem L is W[t]-hard with respect to p, then L is assumed to not be fixed-parameter tractable. Moreover, L is slice-wise polynomial (XP) with respect to p if L can be decided in f(p)|I|g(p) time. Let (I,p) and (I,p) be two instances of L. A reduction to a (problem) kernel for L is a polynomial-time algorithm that computes an instance (I,p) such that

  • p+|I|g(p), and

  • (I,p) is a yes-instance of L if and only if (I,p) is a yes-instance of L.

The instance (I,p) is referred to as the problem kernel and g is the size of the kernel. Furthermore, if g is a polynomial, we say that the kernel is a polynomial problem kernel. For more details about parameterized complexity we refer to the standard monographs [14, 7].

3 NP-Hardness Results

We show NP-hardness for Timeline VC and Timeline DS even when they are restricted to temporal graphs with a maximum snapshot degree of 1 and constant lifetime T, interval number k, and interval length . First, we present the reduction for Timeline VC.

Theorem 3.1.

Timeline VC is NP-hard even if T=23,k=2,=4, and the maximum snapshot degree is one.

Proof.

We reduce from the NP-hard problem 3-Coloring on graphs with maximum degree four [19]. In 3-Coloring the input is a graph and the question is whether the vertices can be colored with three colors such that no two adjacent vertices have the same color.

Intuition.

The basic idea is to construct a temporal graph with three parts C1,C2 and C3 (call them color blocks), each consisting of five snapshots and representing one of the three colors. The part in which a vertex v is not active corresponds to the assigned color of v. As each of the three parts will contain every edge of G and only vertices of degree at most one, this ensures that all neighbors are active in the part where v is not active. Hence, they are assigned a different color. The basic idea for encoding a given graph G into snapshots of maximum degree one is to find a proper edge coloring with five colors and split the edge set with respect to this coloring, which can be done in polynomial time via Vizing’s theorem. Our aim is that no activity interval of any vertex can hit more than one color block. To ensure this, we add sufficiently many empty snapshots between any two parts.

Construction.

Let (G=(V={v1,,vn},E)) be an instance of 3-Coloring on graphs with maximum degree four. We construct the following temporal graph 𝒢 where V(𝒢)=V.

The temporal graph 𝒢 consists of 23 snapshots. It can be seen as a sequence of five parts, namely C1,H1,C2,H2,C3. Parts H1 and H2 consist of 4 empty snapshots and each of C1,C2,C3 consists of 5 snapshots. Thus, snapshots 6 to 9 and 15 to 18 are empty. We denote H1 and H2 as the empty blocks and we call C1,C2 and C3 color blocks as they correspond to the three colors. In the following we formally define the snapshots of the color blocks. All three color blocks C1,C2 and C3 will be identical. Hence, we only formally define C1, that is, snapshots 1 to 5.

Here we exploit the fact that the graph G has maximum degree four, because this implies that there exists a proper edge coloring with at most five colors due to Vizing’s theorem [32], which can be computed in polynomial time [25]. Let E(G)=F1F5 be the partition of E(G) into five colors of some proper edge coloring. Now, snapshot j contains exactly the edges of Fj. Finally, observe that by construction, the maximum degree in each snapshot is at most one. By setting k=2 and =4, we obtain the Timeline VC instance (𝒢,k,).

Correctness.

We show that G is 3-colorable if and only if 𝒢 has a 2-activity 4-timeline 𝒯 covering all temporal edges of 𝒢. In the following we say a vertex v is active during Cj for j[3] to indicate that an activity interval of v starts at the first time step and ends and the last time step of the corresponding part.

() Let ϕ:V(G)[3] be a proper 3-coloring of G. We construct an activity timeline of 𝒢 which covers all temporal edges. For each i[n], the vertex vV(G) is active in the two color blocks, which do not correspond to the assigned color of v. Clearly, this yields a 2-activity timeline 𝒯. It remains to argue that each temporal edge is covered by 𝒯. Since ϕ is a proper 3-coloring, both endpoints of each edge uwE(G) have a different color. Moreover, since in color block Cj all vertices are active which do not have color j, we conclude that all temporal edges of 𝒢 are covered by 𝒯.

() Let 𝒯 be a 2-activity 4-timeline covering all temporal edges of 𝒢. Observe that since parts H1 and H2 corresponding to snapshots 6 to 9 and 15 to 18 are empty, no activity interval of any vertex can hit more than one color block. Consequently, since k=2, for each vertex v there exists at least one color j[3] such that v is not active during any snapshot of color block Cj. Let ϕ(v)[3] be such a color. Note that if ϕ(v) is not unique, we pick any color fulfilling the property. We now argue that ϕ is a proper 3-coloring of G. Assume towards a contradiction that this is not the case, that is, there exists at least one edge uwE(G) such that both endpoints u and w have the same color j. This implies that both u and w are not active during Cj. But since exactly one of the 5 snapshots corresponding to color block Cj contains the edge uw, timeline 𝒯 is not covering all temporal edges of 𝒢, a contradiction. Thus, ϕ is a proper 3-coloring of G. Next, we extend the ideas of this reduction to Timeline DS for which the reduction is more involved since we also need to deal with isolated temporal vertices.

Theorem 3.2 ().

Timeline DS is NP-hard even if T=35,k=3,=6 and the maximum snapshot degree is one.

4 The Influence of Membership-Width Based Parameters

Now, we investigate the membership-width based parameters vimw and imw. More precisely, we study the parameter combinations vimw+k+ and imw+k+. These combinations are motivated by the fact that Timeline VC and Timeline DS are W[1]-hard with respect to n+; for Timeline VC this follows from previous work [18] and for Timeline DS, we will show this in Section 5.

4.1 The Parameter Vertex-Interval-Membership-Width

In this section, we provide FPT-algorithms with respect to vimw+k+ for Timeline PVC and Timeline PDS. Moreover, we show that vimw can be replaced by smaller parameters vimw[x] for all problems except Timeline PDS (the precise value of x differs for Timeline PVC and Timeline DS). Simultaneously, these algorithms also are XP-algorithms for Timeline PVC and Timeline PDS parameterized by vimw alone. Initially, we focus on Timeline (Partial) Vertex Cover and we show that Timeline PVC admits an FPT-algorithm for vimw+k+.

Theorem 4.1 ().

Timeline PVC is solvable in ((k+1)(+2))2vimw(n+T)𝒪(1) time.

Proof.

Let (𝒢=(G1,,GT),k,,t) be an instance of Timeline PVC. Further, suppose that Tk(+1)+1 (otherwise, it is a trivial instance) and that the underlying graph G contains no isolated vertex v. Otherwise, since v does not cover any temporal edge, v can be safely removed and consequently t remains unchanged. Moreover, we assume that each vertex v is contained in at least k(+1)+1 bags (recall that these are consecutive) because otherwise we can simply greedily pick k activity intervals of v which contain all snapshots where v is non-isolated and thus we cover all temporal edges incident with v. Thus, it is safe to remove v from 𝒢 and reduce t by the number of temporal edges incident with v over all snapshots.

The idea is to use dynamic programming over the lifetime of the temporal graph. Each table entry corresponds to the maximal number of covered temporal edges where a specific set of vertices in the bag is active. In other words, the dynamic program keeps track of the activity of the vertices which are contained in the bag Fi of the currently considered time step i[T]. While iterating over the lifetime of the temporal graph, we need to ensure that the activities at a time step are compatible with the activities at the neighboring time steps. Moreover, for a vertex v let i and j be the index of the smallest and largest snapshot where v is incident to an edge, respectively. By definition, vFx for any ixj. Furthermore, since v is isolated in all snapshots Gx where x<i or x>j, it is safe to assume that all k activity intervals of v are used when v is contained in the bags Fx.

Recall that the vertex-interval-membership sequence can be computed in polynomial time. Since we assumed that the underlying graph contains no isolated vertex, it follows that each vertex is contained in at least one bag of the sequence.

Table Definition.

We denote Fi:=F1Fi and F¯i:=FiFi. In other words, F¯i is the set of vertices which are isolated in all snapshots Gi,,GT since we assumed that G contains no isolated vertices. Moreover, for i[T] we define functions curr:Fi[0,k], and pos:Fi[0,+1]. The functions curr and pos indicate for each vertex vFi whether an activity interval of v is active during snapshot Gi. More precisely, the function value curr(v) determines the number of the current activity interval of v and the function value pos(v) determines the position in this activity interval. Here, curr(v)=0 means that the current time step is before the first activity interval and pos(v)=0 means that v is currently not active, that is, the curr(v)-th activity interval of v is already over and the next one has not started yet. Now the entry DP[i,curr,pos] contains the maximum number of covered temporal edges in the first i snapshots G1,,Gi, while i is at the pos(v)-th position of the curr(v)-th activity interval of vFi.

The formal definition of the table now is

DP[i,curr,pos]=^max𝒯 |{(e,j)E×[i]:(e,j) is covered by 𝒯}|,

where the maximum is taken over all k-activity -timelines

𝒯(F¯i×[i1]×[T])(Fi×[i]×[T]),

such that for each vFi

  1. (i)

    there are at most curr(v) activity intervals of v in 𝒯,

  2. (ii)

    pos(v)i, and

  3. (iii)

    (v,ipos(v)+1,b)𝒯 for b=min(ipos(v)+1+,T) if pos(v)>0.

We need Conditions (i)-(iii) for the following reasons: Condition (i) ensures that each vertex has at most k activity intervals. Moreover, condition (ii) ensures that no activity interval starts before time step one. Finally, condition (iii) ensures that each activity interval has length , except if the remaining number of snapshots is too small.

Initialization.

For all curr:F1[0,k] and pos:F1[0,1], for which curr(v)=0 implies pos(v)=0, the table is initialized by

DP[1,curr,pos]=|EG1({vF1:pos(v)=1},F1)|.

Note that F¯1= and therefore only activity timelines 𝒯F1×[1]×[T] are considered in the definition of DP[1,curr,pos]. The initialization is correct, since the table entry DP[1,curr,pos] contains the number of temporal edges which are covered by the active vertices from F1 in G1. Observe that the other endpoints of the covered edges are also contained in F1 by definition.

Recurrence.

The remaining table entries are computed recursively. Intuitively, DP[i,curr,pos] is computed by trying all activity interval choices for the vertices of Fi1, such that there is no conflict with curr and pos. Formally, we set

DP[i,curr,pos]=maxcurr,pos DP[i1,curr,pos]+|EGi({vFi:pos(v)1},Fi)|

where the maximum is taken over all curr:Fi1[0,k] and pos:Fi1[0,+1] which are compatible with curr and pos. Informally, curr and pos are compatible with curr and pos if they provide a correct extension of the activities of Fi1Fi at time step i to time step i1. Formally, four conditions need to be fulfilled: First, if an interval of v is already active at time step i, that is, if pos(v)2, then an activity interval of v is already active during time step i1. This can be formalized as follows.

If pos(v)2, then curr(v)curr(v) and pos(v)=pos(v)1. (1)

Second, if a new activity interval of v starts at time step i either v was inactive at time step i1 or the previous activity interval of v ended at time step i1. This can be formalized as follows.

If curr(v)>1 and pos(v)=1, then curr(v)curr(v)1 and pos(v){min(i1,+1),0}. (2)

Third, if the first activity interval of v starts at time step i, then in the previous time step i1 vertex v cannot be active. This can be formalized as follows.

If curr(v)=1 and pos(v)=1, then curr(v)=0 and pos(v)=0. (3)

Finally, if v is not active during time step i, either v is also not active during time step i1 or an activity interval of v ended at time step i1. This can be formalized as follows.

If curr(v)1 and pos(v)=0, then curr(v)curr(v) and pos(v){min(i1,+1),0}. (4)

The minimum in Conditions 2 and 4 ensures that the activity intervals do not have a starting point smaller than one.

Correctness.

We show the correctness of the computation by proving inequalities in both directions.

() Suppose the maximum in the definition of the table entry DP[i,curr,pos] is attained for 𝒯 and assume that no activity intervals from 𝒯 overlap. We define 𝒯 by taking all activity intervals from 𝒯 which are relevant for a table entry of i1. Formally, we define

𝒯:= {(v,a,b)𝒯:ai2,vF¯i1}
{(v,a,b)𝒯:ai1,vFi1},

and, in accordance with 𝒯, functions curr:Fi1[0,k],pos:Fi1[0,+1] by

curr(v) :=|{(v,a,b)𝒯:a,b[T]}|
pos(v) :={iaif (v,a,b)𝒯 with aib0otherwise.

Note that 𝒯𝒯. We show that curr and pos satisfy Conditions (1)–(4). This means that the table entry DP[i1,curr,pos] is considered in the maximum on the right side of the recursive computation. By definition of curr and pos it is clear that 𝒯 is then considered in the definition of the table entry DP[i1,curr,pos]. Now let vFi1Fi.

  1. (1)

    If pos(v)2, then (v,a,b)𝒯 for some ai1,b[T] and by definition of 𝒯, each such activity interval of v in 𝒯 is also contained in 𝒯. Consequently, we have curr(v)curr(v) and pos(v)=pos(v)1.

  2. (2)

    If curr(v)>1 and pos(v)=1, then (v,i,b)𝒯𝒯 for some b[T]. So the activity timeline 𝒯 contains at most curr(v)1 activity intervals of v and therefore curr(v)curr(v)1. Now either (v,a,i1)𝒯 for some a[i1] or v is not active in Gi1 with respect to the activity intervals from 𝒯. This means that either pos(v)=min(i1,+1) or pos(v)=0.

  3. (3)

    If curr(v)=1 and pos(v)=1, then (v,i,b)𝒯𝒯 for some b[T]. Consequently, 𝒯 contains no activity interval of v and therefore curr(v)=pos(v)=0.

  4. (4)

    If curr(v)1 and pos(v)=0, then either (v,a,i1)𝒯 for some a[i1] or v is not active in Gi1 with respect to the activity intervals from 𝒯. So by definition curr(v)curr(v) and either pos(v)=min(i1,+1) or pos(v)=0.

Now consider the set 𝒜 of temporal edges until time step i that are covered by 𝒯 and the set 𝒜 of temporal edges until time step i1 that are covered by 𝒯. There are two cases for a temporal edge (vw,j)𝒜𝒜.

Case 1: j=i.

Since the temporal edge (vw,j) is covered by 𝒯 we can conclude that vwEGi({vFi:pos(v)1},Fi).

Case 2: j<i.

We have (vw,j)(Fi12)×[i1]. This implies the existence of an activity interval (v,a,b) or (w,a,b) in 𝒯 with ai1. However, then the activity interval is by definition contained in 𝒯 and consequently (vw,j)𝒜.

Hence, any temporal edge in 𝒜𝒜 is contained in EGi({vFi:pos(v)1},Fi). We thus have the desired inequality

DP[i,curr,pos]=|𝒜| |𝒜|+|EGi({vFi:pos(v)1},Fi)|
DP[i1,curr,pos]+|EGi({vFi:pos(v)1},Fi)|.

() Suppose the maximum on the right side of the computation is attained for curr,pos and the maximum in the definition of DP[i1,curr,pos] is attained for 𝒯. We define 𝒯 by extending 𝒯 in the following way: For vFi1Fi the activity interval (v,i,min(i+,T)) is added if and only if pos(v)=1. These new intervals together with the already active ones (pos(v)2) cover all edges of EGi({vFi:pos(v)1},Fi). Hence, the total number of edges covered by 𝒯 is DP[i1,curr,pos]+|EGi({vFi:pos(v)1},Fi)|.

Because 𝒯 is considered in the definition of DP[i,curr,pos], we have

DP[i,curr,pos]DP[i1,curr,pos]+|EGi({vFi:pos(v)1},Fi)|.

Hence, the desired inequality holds.

Result.

Finally, we return yes if and only if DP[T,curr,pos]t for curr:FT{k} and some function pos:FT{0,+1}. The restriction to these functions is correct, since we can assume without loss of generality that a vertex is active in GT if and only if its k-th activity interval ends at time step T (recall that we assume that each vertex is in at least k(+1)+1 bags). Consequently, all k-activity -timelines of 𝒢 are considered in the definition of the table entry DP[T,curr,pos] and all covered temporal edges of 𝒢 are counted in the respective maximum of the definition.

Running Time.

For each time step i[T], there are ((k+1)(+2))vimw choices for the functions curr:Fi[0,k] and pos:Fi[0,+1]. This upper-bounds the size of our dynamic programming table by T((k+1)(+2))vimw. In each recursive computation of a table entry, there are also 𝒪(((k+1)(+2))vimw) choices for curr and pos. The remaining summands of the recursive formula can be computed in 𝒪(n) time. Hence, the overall running time can be bounded by ((k+1)(+2))2vimw(n+T)𝒪(1).

Now, we show that for Timeline PVC the parameter vimw=vimw[1] can be replaced by an even smaller parameter, vimw[k(+1)+1]. The algorithm for this parameter has two steps: First it applies a preprocessing step that handles the large bags. Then, it invokes the algorithm of Theorem 4.1 for vimw=vimw[1].

Proposition 4.2.

Timeline PVC is solvable in ((k+1)(+2))4vimw[x](n+T)𝒪(1) time where x=k(+1)+1.

Proof.

Let (Fi)i[T] be the bags of the vertex-interval-membership sequence of 𝒢. Similar to the proof of Theorem 4.1, it is safe to assume that each vertex v is contained in at least k(+1) bags (by definition the bags containing v need to be consecutive) because otherwise, we can greedily pick the k-activity intervals of v such that v is active during all these snapshots and thus all temporal edges incident to v are covered and we can reduce t accordingly.

We call the k(+1) largest bags of (Fi)i[T] large. The idea is to pick the intervals greedily for all vertices that are only contained in large bags. Intuitively, this works since the large bags appear consecutively. Afterwards, we remove all these vertices and adapt t accordingly. Finally, we can invoke the algorithm of Theorem 4.1.

Now, let [i,j][T] be a sequence of consecutive indices such that each bag Fx for each x[i,j] is large. By definition jik(+1)1. Now, let 𝒜=x[i,j]Fx(Fi1Fj+1). If i=0 or j=T, then Fi1 or Fj+1 is simply the empty set. Suppose 𝒜. By definition, each vertex in 𝒜 is isolated in G1,,Gi1 and also in Gj+1,,GT. By our assumption that each vertex is contained in at least k(+1) bags, we can conclude that ji=k(+1)1. Now observe that by picking the k-activity intervals for each vertex in 𝒜 greedily, we can cover all temporal edges which are incident to some vertex of 𝒜. Hence, it is safe to remove 𝒜 from 𝒢 and to reduce t by the number of temporal edges covered by the vertices in 𝒜. For the remaining instance, we use the algorithm of Theorem 4.1. After removing 𝒜, we have |Fx||Fi1|+|Fj+1|2vimw[k(+1)+1] for every x[i,j] and consequently Theorem 4.1 yields the desired running time. Now, suppose 𝒜= and let Fx be a large bag contained in a sequence of large bags with indices [i,j]. In this case, we can conclude |Fx||Fi1|+|Fj+1|2vimw[k(+1)+1] and again apply Theorem 4.1.

Now, we focus on Timeline (Partial) Dominating Set. Initially, we show how to adapt the algorithm of Theorem 4.1 for Timeline PDS to obtain an algorithm with the same running time for Timeline PDS. However, we need to be more careful since isolated vertices in the snapshots can no longer be ignored as for Timeline PVC. This means that vertices which are not contained in the current bag of the vertex-interval-membership sequence might have to be active. Hence, the update of the dynamic program additionally needs to consider the case that activity intervals of vertices appear before or after their first or last occurrence in a bag.

Theorem 4.3 ().

Timeline PDS is solvable in ((k+1)(+2))2vimw(n+T)𝒪(1) time.

Recall that for Timeline PVC we showed that vimw=vimw[1] can be replaced by the much smaller parameter vimw[k(+1)+1], the size of the k(+1)+1 largest bag. Hence, one may ask whether vimw can be replaced by vimw[i] with some suitably chosen i for Timeline DS and Timeline PDS. We show that both problems behave quite differently: First, we show we that vimw can be replaced by vimw[+2] for Timeline DS by having a preprocessing step and then adapting the algorithm behind Theorem 4.3. Second, we show that replacing vimw=vimw[1] by vimw[2] is not possible for Timeline PDS. More precisely, we show NP-hardness even if there are only two snapshots one of which is edgeless (which implies vimw[2]=0).

We start with our result for Timeline DS.

Proposition 4.4 ().

Timeline DS is solvable in ((k+1)(+2))4vimw[x](n+T)𝒪(1) time where x=+2.

Finally, we show hardness for constant k,, and vimw[2] for Timeline PDS.

Theorem 4.5 ().

Timeline PDS is NP-hard even if T=2, k=1, =0, the underlying graph is bipartite, planar, has maximum degree 3, and one snapshot is edgeless.

4.2 The Parameter Interval-Membership-Width

Now, we study the influence of imw instead of vimw. Initially, we show that the parameter imw+k+ yields a polynomial kernel for Timeline DS. This also implies a polynomial kernel for vimw+k+ and n+k+ for Timeline DS. More precisely, we show an even stronger result: We provide a polynomial kernel for q+k+, where q is the maximal number of edges in any snapshot. Note that q is never larger than imw, since any bag Fi contains Ei. Moreover, in the temporal graph 𝒢 with a star on n leaves as underlying graph and lifetime T=2n, where the edge towards the i-th leaf is active at snapshots i and i+n, we have imw=n and q=1.

Theorem 4.6.

Timeline DS has a kernel where both the number of snapshots and vertices are cubic in q+k+ which can be computed in linear time with respect to the input size.

Proof.

In order to provide the kernel we bound the number of snapshots T and the number n of vertices of the underlying graph based on the following case distinction.

Case 1: qn/2.

By definition each k-activity -timeline has active vertices in at most nk(+1) snapshots. Hence, if T>2qk(+1)nk(+1), then the instance is a no-instance.

Case 2.1: q<n/2 and T>2k(+1)+1.

We show that in this case, we are dealing with a no-instance. Since each snapshot contains at most q edges, any set of p vertices can dominate at most p+q vertices in this snapshot. As q<n/2, it follows that at least n/2 vertices must be active in order to dominate all temporal vertices of the corresponding snapshot Gx. Moreover, note that the total number of active vertices in any k-activity -timeline is at most z=nk(+1). Consequently, Tz/(n/2)2k(+1) for any yes-instance.

Case 2.2: q<n/2 and T2k(+1)+1.

If n4qk(+1), then we have the desired bound. Otherwise, if n4qk(+1)+1, we can solve the instance in polynomial time as follows. Since each snapshot has at most q edges, at most 2q vertices are non-isolated in each snapshot. Moreover, since there are at most 2k(+1) snapshots, in total at most 4qk(+1) vertices are non-isolated in the temporal graph. Consequently, since n4qk(+1)+1 there exists at least one vertex v which is isolated in every snapshot. Thus, if Tk(+1)+1 we deal with a trivial no-instance and if Tk(+1) we deal with a trivial yes-instance.

Thus, in each case we either solve the instance (giving a kernel of constant size) or obtain a kernel with at most 2qk(+1) snapshots and at most 4qk(+1) vertices. Moreover, the kernel can be computed in linear time as it involves only computing n, q, and T.

We show that the remaining problems are NP-hard if imw+k+𝒪(1).

Theorem 4.7 ().

Timeline VC is NP-hard even if k=2, =0, imw=4, each edge of the underlying graph exists in exactly one snapshot, and the underlying graph has a constant maximum degree.

Theorem 4.8 ().

Timeline PDS is NP-hard even if k=1, =0, imw=36 and the underlying graph has a constant maximum degree.

5 Complexity with respect to Input Parameters

Finally, we study the influence of the input parameters n,k,, and t on the complexity of Timeline (Partial) Vertex Cover and Timeline (Partial) Dominating Set. Both Timeline VC and Timeline DS are NP-hard for constant values of k and . Consequently, larger parameters need to be considered to obtain FPT-algorithms or XP-algorithms. Froese et al. [18, Theorem 8] showed that Timeline VC admits an FPT-algorithm for n+k. A similar algorithm also works for Timeline DS.

Theorem 5.1 ().

Timeline DS is solvable in time 𝒪(n2+nkT).

Froese et al. [18, Theorem 12] showed that Timeline VC is W[1]-hard for n even if =1 with a reduction from Unary Bin Packing and using a multicolored and a nonuniform variant of Timeline VC as intermediate problems in the reduction. In Nonuniform Timeline VC we are not given a single number of permitted activity intervals k, but instead a number kv for each vertex v. In a similar way we introduce Nonuniform Timeline DS, which we will use as an intermediate problem to show hardness for n+ for Timeline DS.

Theorem 5.2 ().

Timeline DS parameterized by n is W[1]-hard even if =1.

The W[1]-hardness results for both problems do not apply to the case =0. For Timeline VC, this case is fixed-parameter tractable because there exists an ILP formulation in which the number of variables is bounded by some function of n [18, Lemma 10]. It is also straightforward to extend this ILP formulation to Timeline PVC. To complete the picture, we extend the ILP formulation also to Timeline PDS, thus showing that it is fixed-parameter tractable for =0 as well.

Theorem 5.3 ().

Timeline PDS is fixed-parameter tractable with respect to n if =0.

Finally, we show that both Timeline PDS and Timeline PVC can be solved in 2𝒪(t)(n+T)𝒪(1) time, where t denotes the number of temporal vertices/edges, which need to be dominated/covered. Recall that Dondi et al. [12, Theorem 6] provided an FPT-algorithm for Timeline PVC with running time tt(n+T)𝒪(1) if k=1. Hence, our approach improves upon their running time and is not limited to k=1. The idea is to use color coding [2], a very popular technique to obtain FPT-algorithms [7]. To provide deterministic algorithm, we use (n,k)-perfect hash families which can be computed efficiently [26].

Theorem 5.4 ().

Timeline PDS and Timeline PVC are solvable in 2𝒪(t)(n+T)𝒪(1) time.

6 Conclusion

We studied the classical and parameterized complexity of Timeline (Partial) Vertex Cover and Timeline (Partial) Dominating Set. We showed that all problems admit FPT-algorithms for vimw+k+, where vimw is the vertex-interval-membership width. Our running time bounds also give XP-algorithms for vimw alone. For Timeline VC this improves upon an XP-algorithm for n [18]. Moreover, we showed that the smaller parameter imw+k+ leads to para-NP-hardness for all problems except Timeline DS. Hence, we discovered a parameter where a dominating set problem is tractable while the corresponding vertex cover variant is not.

For future work it is interesting to investigate whether already the parameter vimw+k yields an FPT-algorithm for any problem in our study. Moreover, it is open whether Timeline PVC and Timeline PDS admit an FPT-algorithm with respect to n+k. Even for k=1 fixed-parameter tractability with respect to n is still open. Moreover, one could investigate the complexity with respect to other temporal graph parameters such as the temporal neighborhood diversity [15] or temporal graph parameters that are sensitive to the order of the snapshots [6, 5].

A further problem related to Timeline VC is MinTimeline+. In this problem, the value of bounds the sum of the lengths of the activity intervals instead of the length of the longest activity interval. MinTimeline+ was also introduced by Rozhenstein et al. [28] and studied in several works [18, 10, 11, 9, 13, 29, 24]. To distinguish this problem from the other problems in our naming convention, Timeline VC (MinTimeline) could be called MinMax Timeline VC and MinTimeline+ could be called Sum Timeline VC, and the timeline variants of Dominating Set could be named analogously. It is open which of our positive results for vimw and imw can be transferred to the Sum variants of the problems. Finally, it is interesting to study other classic problems as Feedback Vertex Set in the MinMax Timeline and Sum Timeline setting.

References

  • [1] Eleni C. Akrida, George B. Mertzios, Paul G. Spirakis, and Viktor Zamaraev. Temporal vertex cover with a sliding time window. J. Comput. Syst. Sci., 107:108–123, 2020. doi:10.1016/J.JCSS.2019.08.002.
  • [2] Noga Alon, Raphael Yuster, and Uri Zwick. Color-coding. J. ACM, 42(4):844–856, 1995. doi:10.1145/210332.210337.
  • [3] Benjamin Merlin Bumpus and Kitty Meeks. Edge exploration of temporal graphs. Algorithmica, 85(3):688–716, 2023. doi:10.1007/S00453-022-01018-7.
  • [4] Arnaud Casteigts. A Journey through Dynamic Networks (with Excursions). Habilitation thesis, Université de Bordeaux, 2018. URL: https://tel.archives-ouvertes.fr/tel-01883384.
  • [5] Arnaud Casteigts, Nils Morawietz, and Petra Wolf. Distance to Transitivity: New Parameters for Taming Reachability in Temporal Graphs. In Proceedings of the 49th International Symposium on Mathematical Foundations of Computer Science (MFCS ’24), volume 306 of LIPIcs, pages 36:1–36:17. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.MFCS.2024.36.
  • [6] Filippos Christodoulou, Pierluigi Crescenzi, Andrea Marino, Ana Silva, and Dimitrios M. Thilikos. Making the interval membership width of temporal graphs connected and bidirectional. In Proceedings of the 35th International Workshop on Combinatorial Algorithms (IWOCA ’24), volume 14764 of Lecture Notes in Computer Science, pages 247–258. Springer, 2024. doi:10.1007/978-3-031-63021-7_19.
  • [7] Marek Cygan, Fedor V. Fomin, Lukasz Kowalik, Daniel Lokshtanov, Dániel Marx, Marcin Pilipczuk, Michal Pilipczuk, and Saket Saurabh. Parameterized Algorithms. Springer, 2015. doi:10.1007/978-3-319-21275-3.
  • [8] Reinhard Diestel. Graph Theory, 4th Edition, volume 173 of Graduate Texts in Mathematics. Springer, 2012.
  • [9] Riccardo Dondi. Insights into the Complexity of Disentangling Temporal Graphs. In Proceedings of the 23rd Italian Conference on Theoretical Computer Science (ICTCS ’22), volume 3284 of CEUR Workshop Proceedings, pages 1–13. CEUR-WS.org, 2022. URL: https://ceur-ws.org/Vol-3284/2973.pdf.
  • [10] Riccardo Dondi. Untangling temporal graphs of bounded degree. Theor. Comput. Sci., 969:114040, 2023. doi:10.1016/J.TCS.2023.114040.
  • [11] Riccardo Dondi and Manuel Lafond. An FPT algorithm for timeline cover. J. Comput. Syst. Sci., 154:103679, 2025. doi:10.1016/J.JCSS.2025.103679.
  • [12] Riccardo Dondi, Fabrizio Montecchiani, Giacomo Ortali, Tommaso Piselli, and Alessandra Tappini. Partial temporal vertex cover with bounded activity intervals. In Proceedings of the 3rd Symposium on Algorithmic Foundations of Dynamic Networks (SAND ’24), volume 292 of LIPIcs, pages 11:1–11:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.SAND.2024.11.
  • [13] Riccardo Dondi and Alexandru Popa. Exact and approximation algorithms for covering timeline in temporal graphs. Ann. Oper. Res., 351(1):609–628, 2025. doi:10.1007/s10479-024-05993-8.
  • [14] Rodney G. Downey and Michael Ralph Fellows. Fundamentals of Parameterized Complexity. Springer Science & Business Media, 2013.
  • [15] Jessica A. Enright, Samuel D. Hand, Laura Larios-Jones, and Kitty Meeks. Structural parameters for dense temporal graphs. In Proceedings of the 49th International Symposium on Mathematical Foundations of Computer Science (MFCS ’24), volume 306 of LIPIcs, pages 52:1–52:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.MFCS.2024.52.
  • [16] David Eppstein and Emma S. Spiro. The h-index of a graph and its application to dynamic subgraph statistics. J. Graph Algorithms Appl., 16(2):543–567, 2012. doi:10.7155/JGAA.00273.
  • [17] Till Fluschnik, Rolf Niedermeier, Valentin Rohm, and Philipp Zschoche. Multistage vertex cover. Theory Comput. Syst., 66(2):454–483, 2022. doi:10.1007/s00224-022-10069-w.
  • [18] Vincent Froese, Pascal Kunz, and Philipp Zschoche. Disentangling the computational complexity of network untangling. Theory Comput. Syst., 68(1):103–121, 2024. doi:10.1007/S00224-023-10150-Y.
  • [19] M. R. Garey, David S. Johnson, and Larry J. Stockmeyer. Some simplified NP-complete problems. In Proceedings of the 6th Annual ACM Symposium on Theory of Computing, pages 47–63. ACM, 1974. doi:10.1145/800119.803884.
  • [20] Thekla Hamm, Nina Klobas, George B. Mertzios, and Paul G. Spirakis. The complexity of temporal vertex cover in small-degree graphs. In Proceedings of the Thirty-Sixth AAAI Conference on Artificial Intelligence (AAAI ’22), pages 10193–10201. AAAI Press, 2022. doi:10.1609/AAAI.V36I9.21259.
  • [21] Anton Herrmann. On the complexity of computing optimal dominating sets in temporal graphs. Master’s thesis, Friedrich-Schiller-Universität Jena, 2024.
  • [22] Anton Herrmann, Christian Komusiewicz, Nils Morawietz, and Frank Sommer. Temporal dominating set and temporal vertex cover under the lense of degree restrictions. In Proceedings of the 4th Symposium on Algorithmic Foundations of Dynamic Networks (SAND ’25), volume 330 of LIPIcs, pages 16:1–16:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPICS.SAND.2025.16.
  • [23] David C. Kutner and Laura Larios-Jones. Temporal reachability dominating sets: Contagion in temporal graphs. J. Comput. Syst. Sci., 155:103701, 2026. doi:10.1016/J.JCSS.2025.103701.
  • [24] Giorgio Lazzarinetti, Sara Manzoni, Italo Zoppis, and Riccardo Dondi. FastMinTC+: A Fast and Effective Heuristic for Minimum Timeline Cover on Temporal Networks. In Proceedings of the 31st International Symposium on Temporal Representation and Reasoning (TIME ’24), volume 318 of LIPIcs, pages 20:1–20:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPICS.TIME.2024.20.
  • [25] Jayadev Misra and David Gries. A constructive proof of Vizing’s theorem. Inf. Process. Lett., 41(3):131–133, 1992. doi:10.1016/0020-0190(92)90041-S.
  • [26] Moni Naor, Leonard J. Schulman, and Aravind Srinivasan. Splitters and near-optimal derandomization. In Proceedings of the 36th Annual Symposium on Foundations of Computer Science (FOCS ’95), pages 182–191. IEEE Computer Society, 1995. doi:10.1109/SFCS.1995.492475.
  • [27] Tayler Pino, Salimur Choudhury, and Fadi Al-Turjman. Dominating set algorithms for wireless sensor networks survivability. IEEE Access, 6:17527–17532, 2018. doi:10.1109/ACCESS.2018.2819083.
  • [28] Polina Rozenshtein, Nikolaj Tatti, and Aristides Gionis. The network-untangling problem: from interactions to activity timelines. Data Min. Knowl. Discov., 35(1):213–247, 2021. doi:10.1007/S10618-020-00717-5.
  • [29] Carsten Schubert. Leveraging graph structure to untangle temporal networks efficiently. Master’s thesis, TU Berlin, Institute of Software Engineering and Theoretical Computer Science, 2023.
  • [30] I. Stojmenovic, M. Seddigh, and J. Zunic. Dominating sets and neighbor elimination-based broadcasting algorithms in wireless networks. IEEE Trans. Parallel Distributed Syst., 13(1):14–25, 2002. doi:10.1109/71.980024.
  • [31] M Verheije. Algorithms for domination problems on temporal graphs. Master’s thesis, Utrecht University, Graduate School of Natural Sciences, 2021.
  • [32] Vadim G Vizing. On an estimate of the chromatic class of a p-graph. Discret Analiz, 3:25–30, 1964.