109,828 research outputs found
Improved Distributed Algorithms for Exact Shortest Paths
Computing shortest paths is one of the central problems in the theory of
distributed computing. For the last few years, substantial progress has been
made on the approximate single source shortest paths problem, culminating in an
algorithm of Becker et al. [DISC'17] which deterministically computes
-approximate shortest paths in time, where
is the hop-diameter of the graph. Up to logarithmic factors, this time
complexity is optimal, matching the lower bound of Elkin [STOC'04].
The question of exact shortest paths however saw no algorithmic progress for
decades, until the recent breakthrough of Elkin [STOC'17], which established a
sublinear-time algorithm for exact single source shortest paths on undirected
graphs. Shortly after, Huang et al. [FOCS'17] provided improved algorithms for
exact all pairs shortest paths problem on directed graphs.
In this paper, we present a new single-source shortest path algorithm with
complexity . For polylogarithmic , this improves
on Elkin's bound and gets closer to the
lower bound of Elkin [STOC'04]. For larger values of
, we present an improved variant of our algorithm which achieves complexity
, and
thus compares favorably with Elkin's bound of in essentially the entire range of parameters. This
algorithm provides also a qualitative improvement, because it works for the
more challenging case of directed graphs (i.e., graphs where the two directions
of an edge can have different weights), constituting the first sublinear-time
algorithm for directed graphs. Our algorithm also extends to the case of exact
-source shortest paths...Comment: 26 page
On Approximating the Number of -cliques in Sublinear Time
We study the problem of approximating the number of -cliques in a graph
when given query access to the graph.
We consider the standard query model for general graphs via (1) degree
queries, (2) neighbor queries and (3) pair queries. Let denote the number
of vertices in the graph, the number of edges, and the number of
-cliques. We design an algorithm that outputs a
-approximation (with high probability) for , whose
expected query complexity and running time are
O\left(\frac{n}{C_k^{1/k}}+\frac{m^{k/2}}{C_k}\right)\poly(\log
n,1/\varepsilon,k).
Hence, the complexity of the algorithm is sublinear in the size of the graph
for . Furthermore, we prove a lower bound showing that
the query complexity of our algorithm is essentially optimal (up to the
dependence on , and ).
The previous results in this vein are by Feige (SICOMP 06) and by Goldreich
and Ron (RSA 08) for edge counting () and by Eden et al. (FOCS 2015) for
triangle counting (). Our result matches the complexities of these
results.
The previous result by Eden et al. hinges on a certain amortization technique
that works only for triangle counting, and does not generalize for larger
cliques. We obtain a general algorithm that works for any by
designing a procedure that samples each -clique incident to a given set
of vertices with approximately equal probability. The primary difficulty is in
finding cliques incident to purely high-degree vertices, since random sampling
within neighbors has a low success probability. This is achieved by an
algorithm that samples uniform random high degree vertices and a careful
tradeoff between estimating cliques incident purely to high-degree vertices and
those that include a low-degree vertex
An ETH-Tight Exact Algorithm for Euclidean TSP
We study exact algorithms for {\sc Euclidean TSP} in . In the
early 1990s algorithms with running time were presented for
the planar case, and some years later an algorithm with
running time was presented for any . Despite significant interest in
subexponential exact algorithms over the past decade, there has been no
progress on {\sc Euclidean TSP}, except for a lower bound stating that the
problem admits no algorithm unless ETH fails. Up to
constant factors in the exponent, we settle the complexity of {\sc Euclidean
TSP} by giving a algorithm and by showing that a
algorithm does not exist unless ETH fails.Comment: To appear in FOCS 201
Exact bounds for distributed graph colouring
We prove exact bounds on the time complexity of distributed graph colouring.
If we are given a directed path that is properly coloured with colours, by
prior work it is known that we can find a proper 3-colouring in communication rounds. We close the gap between upper and
lower bounds: we show that for infinitely many the time complexity is
precisely communication rounds.Comment: 16 pages, 3 figure
Exact Inference Techniques for the Analysis of Bayesian Attack Graphs
Attack graphs are a powerful tool for security risk assessment by analysing
network vulnerabilities and the paths attackers can use to compromise network
resources. The uncertainty about the attacker's behaviour makes Bayesian
networks suitable to model attack graphs to perform static and dynamic
analysis. Previous approaches have focused on the formalization of attack
graphs into a Bayesian model rather than proposing mechanisms for their
analysis. In this paper we propose to use efficient algorithms to make exact
inference in Bayesian attack graphs, enabling the static and dynamic network
risk assessments. To support the validity of our approach we have performed an
extensive experimental evaluation on synthetic Bayesian attack graphs with
different topologies, showing the computational advantages in terms of time and
memory use of the proposed techniques when compared to existing approaches.Comment: 14 pages, 15 figure
On the Computational Complexity of Vertex Integrity and Component Order Connectivity
The Weighted Vertex Integrity (wVI) problem takes as input an -vertex
graph , a weight function , and an integer . The
task is to decide if there exists a set such that the weight
of plus the weight of a heaviest component of is at most . Among
other results, we prove that:
(1) wVI is NP-complete on co-comparability graphs, even if each vertex has
weight ;
(2) wVI can be solved in time;
(3) wVI admits a kernel with at most vertices.
Result (1) refutes a conjecture by Ray and Deogun and answers an open
question by Ray et al. It also complements a result by Kratsch et al., stating
that the unweighted version of the problem can be solved in polynomial time on
co-comparability graphs of bounded dimension, provided that an intersection
model of the input graph is given as part of the input.
An instance of the Weighted Component Order Connectivity (wCOC) problem
consists of an -vertex graph , a weight function ,
and two integers and , and the task is to decide if there exists a set
such that the weight of is at most and the weight of
a heaviest component of is at most . In some sense, the wCOC problem
can be seen as a refined version of the wVI problem. We prove, among other
results, that:
(4) wCOC can be solved in time on interval graphs,
while the unweighted version can be solved in time on this graph
class;
(5) wCOC is W[1]-hard on split graphs when parameterized by or by ;
(6) wCOC can be solved in time;
(7) wCOC admits a kernel with at most vertices.
We also show that result (6) is essentially tight by proving that wCOC cannot
be solved in time, unless the ETH fails.Comment: A preliminary version of this paper already appeared in the
conference proceedings of ISAAC 201
Minimum Degree up to Local Complementation: Bounds, Parameterized Complexity, and Exact Algorithms
The local minimum degree of a graph is the minimum degree that can be reached
by means of local complementation. For any n, there exist graphs of order n
which have a local minimum degree at least 0.189n, or at least 0.110n when
restricted to bipartite graphs. Regarding the upper bound, we show that for any
graph of order n, its local minimum degree is at most 3n/8+o(n) and n/4+o(n)
for bipartite graphs, improving the known n/2 upper bound. We also prove that
the local minimum degree is smaller than half of the vertex cover number (up to
a logarithmic term). The local minimum degree problem is NP-Complete and hard
to approximate. We show that this problem, even when restricted to bipartite
graphs, is in W[2] and FPT-equivalent to the EvenSet problem, which
W[1]-hardness is a long standing open question. Finally, we show that the local
minimum degree is computed by a O*(1.938^n)-algorithm, and a
O*(1.466^n)-algorithm for the bipartite graphs
Fine-grained complexity of coloring unit disks and balls
On planar graphs, many classic algorithmic problems enjoy a certain "square root phenomenon" and can be solved significantly faster than what is known to be possible on general graphs: for example, Independent Set, 3-Coloring, Hamiltonian Cycle, Dominating Set can be solved in time 2^O(sqrt{n}) on an n-vertex planar graph, while no 2^o(n) algorithms exist for general graphs, assuming the Exponential Time Hypothesis (ETH). The square root in the exponent seems to be best possible for planar graphs: assuming the ETH, the running time for these problems cannot be improved to 2^o(sqrt{n}). In some cases, a similar speedup can be obtained for 2-dimensional geometric problems, for example, there are 2^O(sqrt{n}log n) time algorithms for Independent Set on unit disk graphs or for TSP on 2-dimensional point sets.
In this paper, we explore whether such a speedup is possible for geometric coloring problems. On the one hand, geometric objects can behave similarly to planar graphs: 3-Coloring can be solved in time 2^O(sqrt{n}) on the intersection graph of n unit disks in the plane and, assuming the ETH, there is no such algorithm with running time 2^o(sqrt{n}). On the other hand, if the number L of colors is part of the input, then no such speedup is possible: Coloring the intersection graph of n unit disks with L colors cannot be solved in time 2^o(n), assuming the ETH. More precisely, we exhibit a smooth increase of complexity as the number L of colors increases: If we restrict the number of colors to L=Theta(n^alpha) for some 0<=alpha<=1, then the problem of coloring the intersection graph of n unit disks with L colors
* can be solved in time exp(O(n^{{1+alpha}/2}log n))=exp( O(sqrt{nL}log n)), and
* cannot be solved in time exp(o(n^{{1+alpha}/2}))=exp(o(sqrt{nL})), unless the ETH fails.
More generally, we consider the problem of coloring d-dimensional unit balls in the Euclidean space and obtain analogous results showing that the problem
* can be solved in time exp(O(n^{{d-1+alpha}/d}log n))=exp(O(n^{1-1/d}L^{1/d}log n)), and
* cannot be solved in time exp(n^{{d-1+alpha}/d-epsilon})= exp (O(n^{1-1/d-epsilon}L^{1/d})) for any epsilon>0, unless the ETH fails
- …