arXiv subjects

George B. Mertzios

Publications and source records attributed to George B. Mertzios.

At least 37 records · Page 2Linked to original sources

arXiv2021

Interference-free Walks in Time: Temporally Disjoint Paths

We investigate the computational complexity of finding temporally disjoint paths or walks in temporal graphs. There, the edge set changes over discrete time steps and a temporal path (resp. walk) uses edges that appear at monotonically increasing time steps. Two paths (or walks) are temporally disjoint if they never use the same vertex at the same time; otherwise, they interfere. This reflects applications in robotics, traffic routing, or finding safe pathways in dynamically changing networks. On the one extreme, we show that on general graphs the problem is computationally hard. The "walk version" is W[1]-hard when parameterized by the number of routes. However, it is polynomial-time solvable for any constant number of walks. The "path version" remains NP-hard even if we want to find only two temporally disjoint paths. On the other extreme, restricting the input temporal graph to have a path as underlying graph, quite counterintuitively, we find NP-hardness in general but also identify natural tractable cases.

cs.DS↗

arXiv2021

Deleting edges to restrict the size of an epidemic in temporal networks

Spreading processes on graphs are a natural model for a wide variety of real-world phenomena, including information spread over social networks and biological diseases spreading over contact networks. Often, the networks over which these processes spread are dynamic in nature, and can be modeled with temporal graphs. Here, we study the problem of deleting edges from a given temporal graph in order to reduce the number of vertices (temporally) reachable from a given starting point. This could be used to control the spread of a disease, rumour, etc. in a temporal graph. In particular, our aim is to find a temporal subgraph in which a process starting at any single vertex can be transferred to only a limited number of other vertices using a temporally-feasible path. We introduce a natural edge-deletion problem for temporal graphs and provide positive and negative results on its computational complexity and approximability.

cs.DS↗

arXiv2021

Polynomial Fixed-Parameter Algorithms: A Case Study for Longest Path on Interval Graphs

We study the design of fixed-parameter algorithms for problems already known to be solvable in polynomial time. The main motivation is to get more efficient algorithms for problems with unattractive polynomial running times. Here, we focus on a fundamental graph problem: Longest Path, that is, given an undirected graph, find a maximum-length path in $G$. Longest Path is NP-hard in general but known to be solvable in $O(n^{4})$ time on $n$-vertex interval graphs. We show how to solve Longest Path on Interval Graphs, parameterized by vertex deletion number $k$ to proper interval graphs, in $O(k^{9}n)$ time. Notably, Longest Path is trivially solvable in linear time on proper interval graphs, and the parameter value $k$ can be approximated up to a factor of 4 in linear time. From a more general perspective, we believe that using parameterized complexity analysis may enable a refined understanding of efficiency aspects for polynomial-time solvable problems similarly to what classical parameterized complexity analysis does for NP-hard problems.

cs.CC↗

arXiv2020

Computing Maximum Matchings in Temporal Graphs

Temporal graphs are graphs whose topology is subject to discrete changes over time. Given a static underlying graph $G$, a temporal graph is represented by assigning a set of integer time-labels to every edge $e$ of $G$, indicating the discrete time steps at which $e$ is active. We introduce and study the complexity of a natural temporal extension of the classical graph problem Maximum Matching, taking into account the dynamic nature of temporal graphs. In our problem, Maximum Temporal Matching, we are looking for the largest possible number of time-labeled edges (simply time-edges) $(e,t)$ such that no vertex is matched more than once within any time window of $Δ$ consecutive time slots, where $Δ\in \mathbb{N}$ is given. The requirement that a vertex cannot be matched twice in any $Δ$-window models some necessary "recovery" period that needs to pass for an entity (vertex) after being paired up for some activity with another entity. We prove strong computational hardness results for Maximum Temporal Matching, even for elementary cases. To cope with this computational hardness, we mainly focus on fixed-parameter algorithms with respect to natural parameters, as well as on polynomial-time approximation algorithms.

cs.DM↗

arXiv2020

Exact and Approximate Algorithms for Computing a Second Hamiltonian Cycle

In this paper we consider the following total functional problem: Given a cubic Hamiltonian graph $G$ and a Hamiltonian cycle $C_0$ of $G$, how can we compute a second Hamiltonian cycle $C_1 \neq C_0$ of $G$? Cedric Smith proved in 1946, using a non-constructive parity argument, that such a second Hamiltonian cycle always exists. Our main result is an algorithm which computes the second Hamiltonian cycle in time $O(n \cdot 2^{(0.3-\varepsilon)n})$ time, for some positive constant $\varepsilon>0$, and in polynomial space, thus improving the state of the art running time for solving this problem. Our algorithm is based on a fundamental structural property of Thomason's lollipop algorithm, which we prove here for the first time. In the direction of approximating the length of a second cycle in a Hamiltonian graph $G$ with a given Hamiltonian cycle $C_0$ (where we may not have guarantees on the existence of a second Hamiltonian cycle), we provide a linear-time algorithm computing a second cycle with length at least $n - 4α(\sqrt{n}+2α)+8$, where $α= \frac{Δ-2}{δ-2}$ and $δ,Δ$ are the minimum and the maximum degree of the graph, respectively. This approximation result also improves the state of the art.

cs.DS↗

arXiv2020

The Power of Data Reduction for Matching

Finding maximum-cardinality matchings in undirected graphs is arguably one of the most central graph primitives. For $m$-edge and $n$-vertex graphs, it is well-known to be solvable in $O(m\sqrt{n})$ time; however, for several applications this running time is still too slow. We investigate how linear-time (and almost linear-time) data reduction (used as preprocessing) can alleviate the situation. More specifically, we focus on (almost) linear-time kernelization. We start a deeper and systematic study both for general graphs and for bipartite graphs. Our data reduction algorithms easily comply (in form of preprocessing) with every solution strategy (exact, approximate, heuristic), thus making them attractive in various settings.

cs.DS↗

arXiv2020

Matching in Stochastically Evolving Graphs

This paper studies the maximum cardinality matching problem in stochastically evolving graphs. We formally define the arrival-departure model with stochastic departures. There, a graph is sampled from a specific probability distribution and it is revealed as a series of snapshots. Our goal is to study algorithms that create a large matching in the sampled graphs. We define the price of stochasticity for this problem which intuitively captures the loss of any algorithm in the worst case in the size of the matching due to the uncertainty of the model. Furthermore, we prove the existence of a deterministic optimal algorithm for the problem. In our second set of results we show that we can efficiently approximate the expected size of a maximum cardinality matching by deriving a fully randomized approximation scheme (FPRAS) for it. The FPRAS is the backbone of a probabilistic algorithm that is optimal when the model is defined over two timesteps. Our last result is an upper bound of $\frac{2}{3}$ on the price of stochasticity. This means that there is no algorithm that can match more than $\frac{2}{3}$ of the edges of an optimal matching in hindsight.

cs.DS↗

arXiv2019

Temporal Vertex Cover with a Sliding Time Window

Modern, inherently dynamic systems are usually characterized by a network structure, i.e. an underlying graph topology, which is subject to discrete changes over time. Given a static underlying graph $G$, a temporal graph can be represented via an assignment of a set of integer time-labels to every edge of $G$, indicating the discrete time steps when this edge is active. While most of the recent theoretical research on temporal graphs has focused on the notion of a temporal path and other "path-related" temporal notions, only few attempts have been made to investigate "non-path" temporal graph problems. In this paper, motivated by applications in sensor and in transportation networks, we introduce and study two natural temporal extensions of the classical problem Vertex Cover. In both cases we wish to minimize the total number of "vertex appearances" that are needed to "cover" the whole temporal graph. In our first problem, Temporal Vertex Cover, the aim is to cover every edge at least once during the lifetime of the temporal graph, where an edge can be covered by one of its endpoints, only at a time step when it is active. In our second, more pragmatic variation Sliding Window Temporal Vertex Cover, we are also given a natural number $Δ$, and our aim is to cover every edge at least once at every $Δ$ consecutive time steps. We present a thorough investigation of the computational complexity and approximability of these two temporal covering problems. In particular, we provide strong hardness results, complemented by various approximation and exact algorithms. Some of our algorithms are polynomial-time, while others are asymptotically almost optimal under the Exponential Time Hypothesis (ETH) and other plausible complexity assumptions.

cs.CC↗

arXiv2019

How fast can we reach a target vertex in stochastic temporal graphs?

Temporal graphs are used to abstractly model real-life networks that are inherently dynamic in nature. Given a static underlying graph $G=(V,E)$, a temporal graph on $G$ is a sequence of snapshots $G_t$, one for each time step $t\geq 1$. In this paper we study stochastic temporal graphs, i.e. stochastic processes $\mathcal{G}$ whose random variables are the snapshots of a temporal graph on $G$. A natural feature observed in various real-life scenarios is a memory effect in the appearance probabilities of particular edges; i.e. the probability an edge $e\in E$ appears at time step $t$ depends on its appearance (or absence) at the previous $k$ steps. In this paper we study the hierarchy of models memory-$k$, addressing this memory effect in an edge-centric network evolution: every edge of $G$ has its own independent probability distribution for its appearance over time. Clearly, for every $k\geq 1$, memory-$(k-1)$ is a special case of memory-$k$. We make a clear distinction between the values $k=0$ ("no memory") and $k\geq 1$ ("some memory"), as in some cases these models exhibit a fundamentally different computational behavior, as our results indicate. For every $k\geq 0$ we investigate the complexity of two naturally related, but fundamentally different, temporal path (journey) problems: MINIMUM ARRIVAL and BEST POLICY. In the first problem we are looking for the expected arrival time of a foremost journey between two designated vertices $s,y$. In the second one we are looking for the arrival time of the best policy for actually choosing a particular $s$-$y$ journey. We present a detailed investigation of the computational landscape of both problems for the different values of memory $k$. Among other results we prove that, surprisingly, MINIMUM ARRIVAL is strictly harder than BEST POLICY; in fact, for $k=0$, MINIMUM ARRIVAL is #P-hard while BEST POLICY is solvable in $O(n^2)$ time.

cs.CC↗

arXiv2019

Sliding Window Temporal Graph Coloring

Graph coloring is one of the most famous computational problems with applications in a wide range of areas such as planning and scheduling, resource allocation, and pattern matching. So far coloring problems are mostly studied on static graphs, which often stand in stark contrast to practice where data is inherently dynamic and subject to discrete changes over time. A temporal graph is a graph whose edges are assigned a set of integer time labels, indicating at which discrete time steps the edge is active. In this paper we present a natural temporal extension of the classical graph coloring problem. Given a temporal graph and a natural number $Δ$, we ask for a coloring sequence for each vertex such that (i) in every sliding time window of $Δ$ consecutive time steps, in which an edge is active, this edge is properly colored (i.e. its endpoints are assigned two different colors) at least once during that time window, and (ii) the total number of different colors is minimized. This sliding window temporal coloring problem abstractly captures many realistic graph coloring scenarios in which the underlying network changes over time, such as dynamically assigning communication channels to moving agents. We present a thorough investigation of the computational complexity of this temporal coloring problem. More specifically, we prove strong computational hardness results, complemented by efficient exact and approximation algorithms. Some of our algorithms are linear-time fixed-parameter tractable with respect to appropriate parameters, while others are asymptotically almost optimal under the Exponential Time Hypothesis (ETH).

cs.DM↗

arXiv2018

Kernelization Lower Bounds for Finding Constant-Size Subgraphs

Kernelization is an important tool in parameterized algorithmics. Given an input instance accompanied by a parameter, the goal is to compute in polynomial time an equivalent instance of the same problem such that the size of the reduced instance only depends on the parameter and not on the size of the original instance. In this paper, we provide a first conceptual study on limits of kernelization for several polynomial-time solvable problems. For instance, we consider the problem of finding a triangle with negative sum of edge weights parameterized by the maximum degree of the input graph. We prove that a linear-time computable strict kernel of truly subcubic size for this problem violates the popular APSP-conjecture.

cs.CC↗

arXiv2018

A Linear-Time Algorithm for Maximum-Cardinality Matching on Cocomparability Graphs

Finding maximum-cardinality matchings in undirected graphs is arguably one of the most central graph problems. For general m-edge and n-vertex graphs, it is well-known to be solvable in $O(m \sqrt{n})$ time. We develop a linear-time algorithm to find maximum-cardinality matchings on cocomparability graphs, a prominent subclass of perfect graphs that contains interval graphs as well as permutation graphs. Our algorithm is based on the recently discovered Lexicographic Depth First Search (LDFS).

cs.DS↗

arXiv2018

Binary Search in Graphs Revisited

In the classical binary search in a path the aim is to detect an unknown target by asking as few queries as possible, where each query reveals the direction to the target. This binary search algorithm has been recently extended by [Emamjomeh-Zadeh et al., STOC, 2016] to the problem of detecting a target in an arbitrary graph. Similarly to the classical case in the path, the algorithm of Emamjomeh-Zadeh et al. maintains a candidates' set for the target, while each query asks an appropriately chosen vertex-- the "median"--which minimises a potential $Φ$ among the vertices of the candidates' set. In this paper we address three open questions posed by Emamjomeh-Zadeh et al., namely (a) detecting a target when the query response is a direction to an approximately shortest path to the target, (b) detecting a target when querying a vertex that is an approximate median of the current candidates' set (instead of an exact one), and (c) detecting multiple targets, for which to the best of our knowledge no progress has been made so far. We resolve questions (a) and (b) by providing appropriate upper and lower bounds, as well as a new potential $Γ$ that guarantees efficient target detection even by querying an approximate median each time. With respect to (c), we initiate a systematic study for detecting two targets in graphs and we identify sufficient conditions on the queries that allow for strong (linear) lower bounds and strong (polylogarithmic) upper bounds for the number of queries. All of our positive results can be derived using our new potential $Γ$ that allows querying approximate medians.

cs.DS↗

arXiv2018

Temporal Network Optimization Subject to Connectivity Constraints

In this work we consider \emph{temporal networks}, i.e. networks defined by a \emph{labeling} $λ$ assigning to each edge of an \emph{underlying graph} $G$ a set of \emph{discrete} time-labels. The labels of an edge, which are natural numbers, indicate the discrete time moments at which the edge is available. We focus on \emph{path problems} of temporal networks. In particular, we consider \emph{time-respecting} paths, i.e. paths whose edges are assigned by $λ$ a strictly increasing sequence of labels. We begin by giving two efficient algorithms for computing shortest time-respecting paths on a temporal network. We then prove that there is a \emph{natural analogue of Menger's theorem} holding for arbitrary temporal networks. Finally, we propose two \emph{cost minimization parameters} for temporal network design. One is the \emph{temporality} of $G$, in which the goal is to minimize the maximum number of labels of an edge, and the other is the \emph{temporal cost} of $G$, in which the goal is to minimize the total number of labels used. Optimization of these parameters is performed subject to some \emph{connectivity constraint}. We prove several lower and upper bounds for the temporality and the temporal cost of some very basic graph families such as rings, directed acyclic graphs, and trees.

cs.DM↗

arXiv2018

The parameterized complexity of finding secluded solutions to some classical optimization problems on graphs

This work studies the parameterized complexity of finding secluded solutions to classical combinatorial optimization problems on graphs such as finding minimum s-t separators, feedback vertex sets, dominating sets, maximum independent sets, and vertex deletion problems for hereditary graph properties: Herein, one searches not only to minimize or maximize the size of the solution, but also to minimize the size of its neighborhood. This restriction has applications in secure routing and community detection.

cs.CC↗

arXiv2018

The temporal explorer who returns to the base

In this paper we study the problem of exploring a temporal graph (i.e. a graph that changes over time), in the fundamental case where the underlying static graph is a star. The aim of the exploration problem in a temporal star is to find a temporal walk which starts at the center of the star, visits all leafs, and eventually returns back to the center. We initiate a systematic study of the computational complexity of this problem, depending on the number k of time-labels that every edge is allowed to have; that is, on the number k of time points where every edge can be present in the graph. To do so, we distinguish between the decision version StarExp(k) asking whether a complete exploration of the instance exists, and the maximization version MaxStarExp(k) of the problem, asking for an exploration schedule of the greatest possible number of edges in the star. We present here a collection of results establishing the computational complexity of these two problems. On the one hand, we show that both MaxStarExp(2) and StarExp(3) can be efficiently solved in O(n log n) time on a temporal star with n vertices. On the other hand, we show that, for every k >= 6, StarExp(k) is NP-complete and MaxStarExp(k) is APX-hard, and thus it does not admit a PTAS, unless P = NP. The latter result is complemented by a polynomial-time 2-approximation algorithm for MaxStarExp(k), for every k, thus proving that MaxStarExp(k) is APX-complete. Finally, we give a partial characterization of the classes of temporal stars with random labels which are, asymptotically almost surely, yes-instances and no-instances for StarExp(k) respectively.

cs.CC↗

arXiv2018

Lower and Upper Bound for Computing the Size of All Second Neighbourhoods

We consider the problem of computing the size of each $r$-neighbourhood for every vertex of a graph. Specifically, we ask whether the size of the closed second neighbourhood can be computed in subquadratic time. Adapting the SETH reductions by Abboud et al. (2016) that exclude subquadratic algorithms to compute the radius of a graph, we find that a subquadratic algorithm would violate the SETH. On the other hand, a linear fpt-time algorithm by Demaine et al. (2014) parameterized by a certain `sparseness parameter' of the graph is known, where the dependence on the parameter is exponential. We show here that a better dependence is unlikely: for any~$δ< 2$, no algorithm running in time $O(2^{o({\rm vc}(G))} \, n^δ)$, where~${\rm vc}(G)$ is the vertex cover number, is possible unless the SETH fails. We supplement these lower bounds with algorithms that solve the problem in time~$O(2^{{\rm vc}(G)/2} {\rm vc}(G)^2 \cdot n)$ and $O(2^w w \cdot n)$.

cs.DS↗

arXiv2018

Strong Bounds for Evolution in Undirected Graphs

This work studies the generalized Moran process, as introduced by Lieberman et al. [Nature, 433:312-316, 2005]. We introduce the parameterized notions of selective amplifiers and selective suppressors of evolution, i.e. of networks (graphs) with many "strong starts" and many "weak starts" for the mutant, respectively. We first prove the existence of strong selective amplifiers and of (quite) strong selective suppressors. Furthermore we provide strong upper bounds and almost tight lower bounds (by proving the "Thermal Theorem") for the traditional notion of fixation probability of Lieberman et al., i.e. assuming a random initial placement of the mutant.

cs.DS↗