3,070 research outputs found
On Counting Oracles for Path Problems
We initiate the study of counting oracles for various path problems in graphs. Distance oracles have gained a lot of attention in recent years, with studies of the underlying space and time tradeoffs. For a given graph G, a distance oracle is a data structure which can be used to answer distance queries for pairs of vertices s,t in V(G). In this work, we extend the set up to answering counting queries: for a pair of vertices s,t, the oracle needs to provide the number of (shortest or all) paths from s to t. We present O(n^{1.5}) preprocessing time, O(n^{1.5}) space, and O(sqrt{n}) query time algorithms for oracles counting shortest paths in planar graphs and for counting all paths in planar directed acyclic graphs. We extend our results to other graphs which admit small balanced separators and present applications where our oracle improves the currently best known running times
Linear-Space Approximate Distance Oracles for Planar, Bounded-Genus, and Minor-Free Graphs
A (1 + eps)-approximate distance oracle for a graph is a data structure that
supports approximate point-to-point shortest-path-distance queries. The most
relevant measures for a distance-oracle construction are: space, query time,
and preprocessing time. There are strong distance-oracle constructions known
for planar graphs (Thorup, JACM'04) and, subsequently, minor-excluded graphs
(Abraham and Gavoille, PODC'06). However, these require Omega(eps^{-1} n lg n)
space for n-node graphs. We argue that a very low space requirement is
essential. Since modern computer architectures involve hierarchical memory
(caches, primary memory, secondary memory), a high memory requirement in effect
may greatly increase the actual running time. Moreover, we would like data
structures that can be deployed on small mobile devices, such as handhelds,
which have relatively small primary memory. In this paper, for planar graphs,
bounded-genus graphs, and minor-excluded graphs we give distance-oracle
constructions that require only O(n) space. The big O hides only a fixed
constant, independent of \epsilon and independent of genus or size of an
excluded minor. The preprocessing times for our distance oracle are also faster
than those for the previously known constructions. For planar graphs, the
preprocessing time is O(n lg^2 n). However, our constructions have slower query
times. For planar graphs, the query time is O(eps^{-2} lg^2 n). For our
linear-space results, we can in fact ensure, for any delta > 0, that the space
required is only 1 + delta times the space required just to represent the graph
itself
Exact Distance Oracles for Planar Graphs
We present new and improved data structures that answer exact node-to-node
distance queries in planar graphs. Such data structures are also known as
distance oracles. For any directed planar graph on n nodes with non-negative
lengths we obtain the following:
* Given a desired space allocation , we show how to
construct in time a data structure of size that answers
distance queries in time per query.
As a consequence, we obtain an improvement over the fastest algorithm for
k-many distances in planar graphs whenever .
* We provide a linear-space exact distance oracle for planar graphs with
query time for any constant eps>0. This is the first such data
structure with provable sublinear query time.
* For edge lengths at least one, we provide an exact distance oracle of space
such that for any pair of nodes at distance D the query time is
. Comparable query performance had been observed
experimentally but has never been explained theoretically.
Our data structures are based on the following new tool: given a
non-self-crossing cycle C with nodes, we can preprocess G in
time to produce a data structure of size that can
answer the following queries in time: for a query node u, output
the distance from u to all the nodes of C. This data structure builds on and
extends a related data structure of Klein (SODA'05), which reports distances to
the boundary of a face, rather than a cycle.
The best distance oracles for planar graphs until the current work are due to
Cabello (SODA'06), Djidjev (WG'96), and Fakcharoenphol and Rao (FOCS'01). For
and space , we essentially improve the query
time from to .Comment: To appear in the proceedings of the 23rd ACM-SIAM Symposium on
Discrete Algorithms, SODA 201
Efficient Dynamic Approximate Distance Oracles for Vertex-Labeled Planar Graphs
Let be a graph where each vertex is associated with a label. A
Vertex-Labeled Approximate Distance Oracle is a data structure that, given a
vertex and a label , returns a -approximation of
the distance from to the closest vertex with label in . Such
an oracle is dynamic if it also supports label changes. In this paper we
present three different dynamic approximate vertex-labeled distance oracles for
planar graphs, all with polylogarithmic query and update times, and nearly
linear space requirements
Exact Distance Oracles for Planar Graphs with Failing Vertices
We consider exact distance oracles for directed weighted planar graphs in the
presence of failing vertices. Given a source vertex , a target vertex
and a set of failed vertices, such an oracle returns the length of a
shortest -to- path that avoids all vertices in . We propose oracles
that can handle any number of failures. More specifically, for a directed
weighted planar graph with vertices, any constant , and for any , we propose an oracle of size
that answers queries in
time. In particular, we show an
-size, -query-time
oracle for any constant . This matches, up to polylogarithmic factors, the
fastest failure-free distance oracles with nearly linear space. For single
vertex failures (), our -size,
-query-time oracle improves over the previously best
known tradeoff of Baswana et al. [SODA 2012] by polynomial factors for , . For multiple failures, no planarity exploiting
results were previously known
Dynamic Complexity of Planar 3-connected Graph Isomorphism
Dynamic Complexity (as introduced by Patnaik and Immerman) tries to express
how hard it is to update the solution to a problem when the input is changed
slightly. It considers the changes required to some stored data structure
(possibly a massive database) as small quantities of data (or a tuple) are
inserted or deleted from the database (or a structure over some vocabulary).
The main difference from previous notions of dynamic complexity is that instead
of treating the update quantitatively by finding the the time/space trade-offs,
it tries to consider the update qualitatively, by finding the complexity class
in which the update can be expressed (or made). In this setting, DynFO, or
Dynamic First-Order, is one of the smallest and the most natural complexity
class (since SQL queries can be expressed in First-Order Logic), and contains
those problems whose solutions (or the stored data structure from which the
solution can be found) can be updated in First-Order Logic when the data
structure undergoes small changes.
Etessami considered the problem of isomorphism in the dynamic setting, and
showed that Tree Isomorphism can be decided in DynFO. In this work, we show
that isomorphism of Planar 3-connected graphs can be decided in DynFO+ (which
is DynFO with some polynomial precomputation). We maintain a canonical
description of 3-connected Planar graphs by maintaining a database which is
accessed and modified by First-Order queries when edges are added to or deleted
from the graph. We specifically exploit the ideas of Breadth-First Search and
Canonical Breadth-First Search to prove the results. We also introduce a novel
method for canonizing a 3-connected planar graph in First-Order Logic from
Canonical Breadth-First Search Trees
Better Tradeoffs for Exact Distance Oracles in Planar Graphs
We present an -space distance oracle for directed planar graphs
that answers distance queries in time. Our oracle both
significantly simplifies and significantly improves the recent oracle of
Cohen-Addad, Dahlgaard and Wulff-Nilsen [FOCS 2017], which uses
-space and answers queries in time. We achieve this by
designing an elegant and efficient point location data structure for Voronoi
diagrams on planar graphs.
We further show a smooth tradeoff between space and query-time. For any , we show an oracle of size that answers queries in time. This new tradeoff is currently the best (up to
polylogarithmic factors) for the entire range of and improves by polynomial
factors over all the previously known tradeoffs for the range
- …