arXiv subjects

Stefano Leucci

Publications and source records attributed to Stefano Leucci.

35 records · Page 2Linked to original sources

arXiv2018

Hardness, Approximability, and Fixed-Parameter Tractability of the Clustered Shortest-Path Tree Problem

Given an $n$-vertex non-negatively real-weighted graph $G$, whose vertices are partitioned into a set of $k$ clusters, a \emph{clustered network design problem} on $G$ consists of solving a given network design optimization problem on $G$, subject to some additional constraint on its clusters. In particular, we focus on the classic problem of designing a \emph{single-source shortest-path tree}, and we analyze its computational hardness when in a feasible solution each cluster is required to form a subtree. We first study the \emph{unweighted} case, and prove that the problem is \np-hard. However, on the positive side, we show the existence of an approximation algorithm whose quality essentially depends on few parameters, but which remarkably is an $O(1)$-approximation when the largest out of all the \emph{diameters} of the clusters is either $O(1)$ or $Θ(n)$. Furthermore, we also show that the problem is \emph{fixed-parameter tractable} with respect to $k$ or to the number of vertices that belong to clusters of size at least 2. Then, we focus on the \emph{weighted} case, and show that the problem can be approximated within a tight factor of $O(n)$, and that it is fixed-parameter tractable as well. Finally, we analyze the unweighted \emph{single-pair shortest path problem}, and we show it is hard to approximate within a (tight) factor of $n^{1-ε}$, for any $ε>0$.

cs.DS↗

arXiv2017

An Improved Algorithm for Computing All the Best Swap Edges of a Tree Spanner

A tree $σ$-spanner of a positively real-weighted $n$-vertex and $m$-edge undirected graph $G$ is a spanning tree $T$ of $G$ which approximately preserves (i.e., up to a multiplicative stretch factor $σ$) distances in $G$. Tree spanners with provably good stretch factors find applications in communication networks, distributed systems, and network design. However, finding an optimal or even a good tree spanner is a very hard computational task. Thus, if one has to face a transient edge failure in $T$, the overall effort that has to be afforded to rebuild a new tree spanner (i.e., computational costs, set-up of new links, updating of the routing tables, etc.) can be rather prohibitive. To circumvent this drawback, an effective alternative is that of associating with each tree edge a best possible (in terms of resulting stretch) swap edge -- a well-established approach in the literature for several other tree topologies. Correspondingly, the problem of computing all the best swap edges of a tree spanner is a challenging algorithmic problem, since solving it efficiently means to exploit the structure of shortest paths not only in $G$, but also in all the scenarios in which an edge of $T$ has failed. For this problem we provide a very efficient solution, running in $O(n^2 \log^4 n)$ time, which drastically improves (almost by a quadratic factor in $n$ in dense graphs!) on the previous known best result.

cs.DS↗

arXiv2017

Sorting with Recurrent Comparison Errors

We present a sorting algorithm for the case of recurrent random comparison errors. The algorithm essentially achieves simultaneously good properties of previous algorithms for sorting $n$ distinct elements in this model. In particular, it runs in $O(n^2)$ time, the maximum dislocation of the elements in the output is $O(\log n)$, while the total dislocation is $O(n)$. These guarantees are the best possible since we prove that even randomized algorithms cannot achieve $o(\log n)$ maximum dislocation with high probability, or $o(n)$ total dislocation in expectation, regardless of their running time.

cs.DS↗

arXiv2017

Effective Edge-Fault-Tolerant Single-Source Spanners via Best (or Good) Swap Edges

Computing \emph{all best swap edges} (ABSE) of a spanning tree $T$ of a given $n$-vertex and $m$-edge undirected and weighted graph $G$ means to select, for each edge $e$ of $T$, a corresponding non-tree edge $f$, in such a way that the tree obtained by replacing $e$ with $f$ enjoys some optimality criterion (which is naturally defined according to some objective function originally addressed by $T$). Solving efficiently an ABSE problem is by now a classic algorithmic issue, since it conveys a very successful way of coping with a (transient) \emph{edge failure} in tree-based communication networks: just replace the failing edge with its respective swap edge, so as that the connectivity is promptly reestablished by minimizing the rerouting and set-up costs. In this paper, we solve the ABSE problem for the case in which $T$ is a \emph{single-source shortest-path tree} of $G$, and our two selected swap criteria aim to minimize either the \emph{maximum} or the \emph{average stretch} in the swap tree of all the paths emanating from the source. Having these criteria in mind, the obtained structures can then be reviewed as \emph{edge-fault-tolerant single-source spanners}. For them, we propose two efficient algorithms running in $O(m n +n^2 \log n)$ and $O(m n \log α(m,n))$ time, respectively, and we show that the guaranteed (either maximum or average, respectively) stretch factor is equal to 3, and this is tight. Moreover, for the maximum stretch, we also propose an almost linear $O(m \log α(m,n))$ time algorithm computing a set of \emph{good} swap edges, each of which will guarantee a relative approximation factor on the maximum stretch of $3/2$ (tight) as opposed to that provided by the corresponding BSE. Surprisingly, no previous results were known for these two very natural swap problems.

cs.DS↗

arXiv2016

Fault-Tolerant Approximate Shortest-Path Trees

The resiliency of a network is its ability to remain \emph{effectively} functioning also when any of its nodes or links fails. However, to reduce operational and set-up costs, a network should be small in size, and this conflicts with the requirement of being resilient. In this paper we address this trade-off for the prominent case of the {\em broadcasting} routing scheme, and we build efficient (i.e., sparse and fast) \emph{fault-tolerant approximate shortest-path trees}, for both the edge and vertex \emph{single-failure} case. In particular, for an $n$-vertex non-negatively weighted graph, and for any constant $\varepsilon >0$, we design two structures of size $O(\frac{n \log n}{\varepsilon^2})$ which guarantee $(1+\varepsilon)$-stretched paths from the selected source also in the presence of an edge/vertex failure. This favorably compares with the currently best known solutions, which are for the edge-failure case of size $O(n)$ and stretch factor 3, and for the vertex-failure case of size $O(n \log n)$ and stretch factor 3. Moreover, we also focus on the unweighted case, and we prove that an ordinary $(α,β)$-spanner can be slightly augmented in order to build efficient fault-tolerant approximate \emph{breadth-first-search trees}.

cs.DS↗

arXiv2016

Compact and Fast Sensitivity Oracles for Single-Source Distances

Let $s$ denote a distinguished source vertex of a non-negatively real weighted and undirected graph $G$ with $n$ vertices and $m$ edges. In this paper we present two efficient \emph{single-source approximate-distance sensitivity oracles}, namely \emph{compact} data structures which are able to \emph{quickly} report an approximate (by a multiplicative stretch factor) distance from $s$ to any node of $G$ following the failure of any edge in $G$. More precisely, we first present a sensitivity oracle of size $O(n)$ which is able to report 2-approximate distances from the source in $O(1)$ time. Then, we further develop our construction by building, for any $0<ε<1$, another sensitivity oracle having size $O\left(n\cdot \frac{1}ε \log \frac{1}ε\right)$, and which is able to report a $(1+ε)$-approximate distance from $s$ to any vertex of $G$ in $O\left(\log n\cdot \frac{1}ε \log \frac{1}ε\right)$ time. Thus, this latter oracle is essentially optimal as far as size and stretch are concerned, and it only asks for a logarithmic query time. Finally, our results are complemented with a space lower bound for the related class of single-source \emph{additively-stretched} sensitivity oracles, which is helpful to realize the hardness of designing compact oracles of this type.

cs.DS↗

arXiv2016

Locality-based Network Creation Games

Network creation games have been extensively studied, both from economists and computer scientists, due to their versatility in modeling individual-based community formation processes, which in turn are the theoretical counterpart of several economics, social, and computational applications on the Internet. In their several variants, these games model the tension of a player between her two antagonistic goals: to be as close as possible to the other players, and to activate a cheapest possible set of links. However, the generally adopted assumption is that players have a \emph{common and complete} information about the ongoing network, which is quite unrealistic in practice. In this paper, we consider a more compelling scenario in which players have only limited information about the network they are embedded in. More precisely, we explore the game-theoretic and computational implications of assuming that players have a complete knowledge of the network structure only up to a given radius $k$, which is one of the most qualified \emph{local-knowledge models} used in distributed computing. To this respect, we define a suitable equilibrium concept, and we provide a comprehensive set of upper and lower bounds to the price of anarchy for the entire range of values of $k$, and for the two classic variants of the game, namely those in which a player's cost --- besides the activation cost of the owned links --- depends on the maximum/sum of all the distances to the other nodes in the network, respectively. These bounds are finally assessed through an extensive set of experiments.

cs.GT↗

arXiv2016

The Limits of Popularity-Based Recommendations, and the Role of Social Ties

In this paper we introduce a mathematical model that captures some of the salient features of recommender systems that are based on popularity and that try to exploit social ties among the users. We show that, under very general conditions, the market always converges to a steady state, for which we are able to give an explicit form. Thanks to this we can tell rather precisely how much a market is altered by a recommendation system, and determine the power of users to influence others. Our theoretical results are complemented by experiments with real world social networks showing that social graphs prevent large market distortions in spite of the presence of highly influential users.

cs.SI↗

arXiv2016

Large Peg-Army Maneuvers

Despite its long history, the classical game of peg solitaire continues to attract the attention of the scientific community. In this paper, we consider two problems with an algorithmic flavour which are related with this game, namely Solitaire-Reachability and Solitaire-Army. In the first one, we show that deciding whether there is a sequence of jumps which allows a given initial configuration of pegs to reach a target position is NP-complete. Regarding Solitaire-Army, the aim is to successfully deploy an army of pegs in a given region of the board in order to reach a target position. By solving an auxiliary problem with relaxed constraints, we are able to answer some open questions raised by Csákány and Juhász (Mathematics Magazine, 2000). To appreciate the combinatorial beauty of our solutions, we recommend to visit the gallery of animations provided at http://solitairearmy.isnphard.com.

cs.DM↗

arXiv2016

Trainyard is NP-Hard

Recently, due to the widespread diffusion of smart-phones, mobile puzzle games have experienced a huge increase in their popularity. A successful puzzle has to be both captivating and challenging, and it has been suggested that this features are somehow related to their computational complexity \cite{Eppstein}. Indeed, many puzzle games --such as Mah-Jongg, Sokoban, Candy Crush, and 2048, to name a few-- are known to be NP-hard \cite{CondonFLS97, culberson1999sokoban, GualaLN14, Mehta14a}. In this paper we consider Trainyard: a popular mobile puzzle game whose goal is to get colored trains from their initial stations to suitable destination stations. We prove that the problem of determining whether there exists a solution to a given Trainyard level is NP-hard. We also \href{http://trainyard.isnphard.com}{provide} an implementation of our hardness reduction.

cs.CC↗

arXiv2016

Multiple-Edge-Fault-Tolerant Approximate Shortest-Path Trees

Let $G$ be an $n$-node and $m$-edge positively real-weighted undirected graph. For any given integer $f \ge 1$, we study the problem of designing a sparse \emph{f-edge-fault-tolerant} ($f$-EFT) $σ${\em -approximate single-source shortest-path tree} ($σ$-ASPT), namely a subgraph of $G$ having as few edges as possible and which, following the failure of a set $F$ of at most $f$ edges in $G$, contains paths from a fixed source that are stretched at most by a factor of $σ$. To this respect, we provide an algorithm that efficiently computes an $f$-EFT $(2|F|+1)$-ASPT of size $O(f n)$. Our structure improves on a previous related construction designed for \emph{unweighted} graphs, having the same size but guaranteeing a larger stretch factor of $3(f+1)$, plus an additive term of $(f+1) \log n$. Then, we show how to convert our structure into an efficient $f$-EFT \emph{single-source distance oracle} (SSDO), that can be built in $\widetilde{O}(f m)$ time, has size $O(fn \log^2 n)$, and is able to report, after the failure of the edge set $F$, in $O(|F|^2 \log^2 n)$ time a $(2|F|+1)$-approximate distance from the source to any node, and a corresponding approximate path in the same amount of time plus the path's size. Such an oracle is obtained by handling another fundamental problem, namely that of updating a \emph{minimum spanning forest} (MSF) of $G$ after that a \emph{batch} of $k$ simultaneous edge modifications (i.e., edge insertions, deletions and weight changes) is performed. For this problem, we build in $O(m \log^3 n)$ time a \emph{sensitivity} oracle of size $O(m \log^2 n)$, that reports in $O(k^2 \log^2 n)$ time the (at most $2k$) edges either exiting from or entering into the MSF. [...]

cs.DS↗

arXiv2015

Path-Fault-Tolerant Approximate Shortest-Path Trees

Let $G=(V,E)$ be an $n$-nodes non-negatively real-weighted undirected graph. In this paper we show how to enrich a {\em single-source shortest-path tree} (SPT) of $G$ with a \emph{sparse} set of \emph{auxiliary} edges selected from $E$, in order to create a structure which tolerates effectively a \emph{path failure} in the SPT. This consists of a simultaneous fault of a set $F$ of at most $f$ adjacent edges along a shortest path emanating from the source, and it is recognized as one of the most frequent disruption in an SPT. We show that, for any integer parameter $k \geq 1$, it is possible to provide a very sparse (i.e., of size $O(kn\cdot f^{1+1/k})$) auxiliary structure that carefully approximates (i.e., within a stretch factor of $(2k-1)(2|F|+1)$) the true shortest paths from the source during the lifetime of the failure. Moreover, we show that our construction can be further refined to get a stretch factor of $3$ and a size of $O(n \log n)$ for the special case $f=2$, and that it can be converted into a very efficient \emph{approximate-distance sensitivity oracle}, that allows to quickly (even in optimal time, if $k=1$) reconstruct the shortest paths (w.r.t. our structure) from the source after a path failure, thus permitting to perform promptly the needed rerouting operations. Our structure compares favorably with previous known solutions, as we discuss in the paper, and moreover it is also very effective in practice, as we assess through a large set of experiments.

cs.DS↗

arXiv2015

Improved Purely Additive Fault-Tolerant Spanners

Let $G$ be an unweighted $n$-node undirected graph. A \emph{$β$-additive spanner} of $G$ is a spanning subgraph $H$ of $G$ such that distances in $H$ are stretched at most by an additive term $β$ w.r.t. the corresponding distances in $G$. A natural research goal related with spanners is that of designing \emph{sparse} spanners with \emph{low} stretch. In this paper, we focus on \emph{fault-tolerant} additive spanners, namely additive spanners which are able to preserve their additive stretch even when one edge fails. We are able to improve all known such spanners, in terms of either sparsity or stretch. In particular, we consider the sparsest known spanners with stretch $6$, $28$, and $38$, and reduce the stretch to $4$, $10$, and $14$, respectively (while keeping the same sparsity). Our results are based on two different constructions. On one hand, we show how to augment (by adding a \emph{small} number of edges) a fault-tolerant additive \emph{sourcewise spanner} (that approximately preserves distances only from a given set of source nodes) into one such spanner that preserves all pairwise distances. On the other hand, we show how to augment some known fault-tolerant additive spanners, based on clustering techniques. This way we decrease the additive stretch without any asymptotic increase in their size. We also obtain improved fault-tolerant additive spanners for the case of one vertex failure, and for the case of $f$ edge failures.

cs.DS↗

arXiv2014

Specializations and Generalizations of the Stackelberg Minimum Spanning Tree Game

Let be given a graph $G=(V,E)$ whose edge set is partitioned into a set $R$ of \emph{red} edges and a set $B$ of \emph{blue} edges, and assume that red edges are weighted and form a spanning tree of $G$. Then, the \emph{Stackelberg Minimum Spanning Tree} (\stack) problem is that of pricing (i.e., weighting) the blue edges in such a way that the total weight of the blue edges selected in a minimum spanning tree of the resulting graph is maximized. \stack \ is known to be \apx-hard already when the number of distinct red weights is 2. In this paper we analyze some meaningful specializations and generalizations of \stack, which shed some more light on the computational complexity of the problem. More precisely, we first show that if $G$ is restricted to be \emph{complete}, then the following holds: (i) if there are only 2 distinct red weights, then the problem can be solved optimally (this contrasts with the corresponding \apx-hardness of the general problem); (ii) otherwise, the problem can be approximated within $7/4 + ε$, for any $ε> 0$. Afterwards, we define a natural extension of \stack, namely that in which blue edges have a non-negative \emph{activation cost} associated, and it is given a global \emph{activation budget} that must not be exceeded when pricing blue edges. Here, after showing that the very same approximation ratio as that of the original problem can be achieved, we prove that if the spanning tree of red edges can be rooted so as that any root-leaf path contains at most $h$ edges, then the problem admits a $(2h+ε)$-approximation algorithm, for any $ε> 0$.

cs.GT↗

arXiv2014

Exact and approximate algorithms for movement problems on (special classes of) graphs

When a large collection of objects (e.g., robots, sensors, etc.) has to be deployed in a given environment, it is often required to plan a coordinated motion of the objects from their initial position to a final configuration enjoying some global property. In such a scenario, the problem of minimizing some function of the distance travelled, and therefore energy consumption, is of vital importance. In this paper we study several motion planning problems that arise when the objects must be moved on a graph, in order to reach certain goals which are of interest for several network applications. Among the others, these goals include broadcasting messages and forming connected or interference-free networks. We study these problems with the aim of minimizing a number of natural measures such as the average/overall distance travelled, the maximum distance travelled, or the number of objects that need to be moved. To this respect, we provide several approximability and inapproximability results, most of which are tight.

cs.DS↗

arXiv2014

The Max-Distance Network Creation Game on General Host Graphs

In this paper we study a generalization of the classic \emph{network creation game} in the scenario in which the $n$ players sit on a given arbitrary \emph{host graph}, which constrains the set of edges a player can activate at a cost of $α\geq 0$ each. This finds its motivations in the physical limitations one can have in constructing links in practice, and it has been studied in the past only when the routing cost component of a player is given by the sum of distances to all the other nodes. Here, we focus on another popular routing cost, namely that which takes into account for each player its \emph{maximum} distance to any other player. For this version of the game, we first analyze some of its computational and dynamic aspects, and then we address the problem of understanding the structure of associated pure Nash equilibria. In this respect, we show that the corresponding price of anarchy (PoA) is fairly bad, even for several basic classes of host graphs. More precisely, we first exhibit a lower bound of $Ω(\sqrt{ n / (1+α)})$ for any $α= o(n)$. Notice that this implies a counter-intuitive lower bound of $Ω(\sqrt{n})$ for very small values of $α$ (i.e., edges can be activated almost for free). Then, we show that when the host graph is restricted to be either $k$-regular (for any constant $k \geq 3$), or a 2-dimensional grid, the PoA is still $Ω(1+\min\{α, \frac{n}α\})$, which is proven to be tight for $α=Ω(\sqrt{n})$. On the positive side, if $α\geq n$, we show the PoA is $O(1)$. Finally, in the case in which the host graph is very sparse (i.e., $|E(H)|=n-1+k$, with $k=O(1)$), we prove that the PoA is $O(1)$, for any $α$.

cs.GT↗

arXiv2014

Bejeweled, Candy Crush and other Match-Three Games are (NP-)Hard

The twentieth century has seen the rise of a new type of video games targeted at a mass audience of "casual" gamers. Many of these games require the player to swap items in order to form matches of three and are collectively known as \emph{tile-matching match-three games}. Among these, the most influential one is arguably \emph{Bejeweled} in which the matched items (gems) pop and the above gems fall in their place. Bejeweled has been ported to many different platforms and influenced an incredible number of similar games. Very recently one of them, named \emph{Candy Crush Saga} enjoyed a huge popularity and quickly went viral on social networks. We generalize this kind of games by only parameterizing the size of the board, while all the other elements (such as the rules or the number of gems) remain unchanged. Then, we prove that answering many natural questions regarding such games is actually \NP-Hard. These questions include determining if the player can reach a certain score, play for a certain number of turns, and others. We also \href{http://candycrush.isnphard.com}{provide} a playable web-based implementation of our reduction.

cs.CC↗