95,397 research outputs found
Watersheds, waterfalls, on edge or node weighted graphs
We present an algebraic approach to the watershed adapted to edge or node
weighted graphs. Starting with the flooding adjunction, we introduce the
flooding graphs, for which node and edge weights may be deduced one from the
other. Each node weighted or edge weighted graph may be transformed in a
flooding graph, showing that there is no superiority in using one or the other,
both being equivalent. We then introduce pruning operators extract subgraphs of
increasing steepness. For an increasing steepness, the number of never
ascending paths becomes smaller and smaller. This reduces the watershed zone,
where catchment basins overlap. A last pruning operator called scissor
associates to each node outside the regional minima one and only one edge. The
catchment basins of this new graph do not overlap and form a watershed
partition. Again, with an increasing steepness, the number of distinct
watershed partitions contained in a graph becomes smaller and smaller.
Ultimately, for natural image, an infinite steepness leads to a unique
solution, as it is not likely that two absolutely identical non ascending paths
of infinite steepness connect a node with two distinct minima. It happens that
non ascending paths of a given steepness are the geodesics of lexicographic
distance functions of a given depth. This permits to extract the watershed
partitions as skeletons by zone of influence of the minima for such
lexicographic distances. The waterfall hierarchy is obtained by a sequence of
operations. The first constructs the minimum spanning forest which spans an
initial watershed partition. The contraction of the trees into one node
produces a reduced graph which may be submitted to the same treatment. The
process is iterated until only one region remains. The union of the edges of
all forests produced constitutes a minimum spanning tree of the initial graph
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
Proving Continuity of Coinductive Global Bisimulation Distances: A Never Ending Story
We have developed a notion of global bisimulation distance between processes
which goes somehow beyond the notions of bisimulation distance already existing
in the literature, mainly based on bisimulation games. Our proposal is based on
the cost of transformations: how much we need to modify one of the compared
processes to obtain the other. Our original definition only covered finite
processes, but a coinductive approach allows us to extend it to cover infinite
but finitary trees. After having shown many interesting properties of our
distance, it was our intention to prove continuity with respect to projections,
but unfortunately the issue remains open. Nonetheless, we have obtained several
partial results that are presented in this paper.Comment: In Proceedings PROLE 2015, arXiv:1512.0617
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
Faster Separators for Shallow Minor-Free Graphs via Dynamic Approximate Distance Oracles
Plotkin, Rao, and Smith (SODA'97) showed that any graph with edges and
vertices that excludes as a depth -minor has a
separator of size and that such a separator can be
found in time. A time bound of for
any constant was later given (W., FOCS'11) which is an
improvement for non-sparse graphs. We give three new algorithms. The first has
the same separator size and running time O(\mbox{poly}(h)\ell
m^{1+\epsilon}). This is a significant improvement for small and .
If for an arbitrarily small chosen constant
, we get a time bound of O(\mbox{poly}(h)\ell n^{1+\epsilon}).
The second algorithm achieves the same separator size (with a slightly larger
polynomial dependency on ) and running time O(\mbox{poly}(h)(\sqrt\ell
n^{1+\epsilon} + n^{2+\epsilon}/\ell^{3/2})) when . Our third algorithm has running time
O(\mbox{poly}(h)\sqrt\ell n^{1+\epsilon}) when . It finds a separator of size O(n/\ell) + \tilde
O(\mbox{poly}(h)\ell\sqrt n) which is no worse than previous bounds when
is fixed and . A main tool in obtaining our results
is a novel application of a decremental approximate distance oracle of Roditty
and Zwick.Comment: 16 pages. Full version of the paper that appeared at ICALP'14. Minor
fixes regarding the time bounds such that these bounds hold also for
non-sparse graph
Efficient Construction of Probabilistic Tree Embeddings
In this paper we describe an algorithm that embeds a graph metric
on an undirected weighted graph into a distribution of tree metrics
such that for every pair , and
. Such embeddings have
proved highly useful in designing fast approximation algorithms, as many hard
problems on graphs are easy to solve on tree instances. For a graph with
vertices and edges, our algorithm runs in time with high
probability, which improves the previous upper bound of shown by
Mendel et al.\,in 2009.
The key component of our algorithm is a new approximate single-source
shortest-path algorithm, which implements the priority queue with a new data
structure, the "bucket-tree structure". The algorithm has three properties: it
only requires linear time in the number of edges in the input graph; the
computed distances have a distance preserving property; and when computing the
shortest-paths to the -nearest vertices from the source, it only requires to
visit these vertices and their edge lists. These properties are essential to
guarantee the correctness and the stated time bound.
Using this shortest-path algorithm, we show how to generate an intermediate
structure, the approximate dominance sequences of the input graph, in time, and further propose a simple yet efficient algorithm to converted
this sequence to a tree embedding in time, both with high
probability. Combining the three subroutines gives the stated time bound of the
algorithm.
Then we show that this efficient construction can facilitate some
applications. We proved that FRT trees (the generated tree embedding) are
Ramsey partitions with asymptotically tight bound, so the construction of a
series of distance oracles can be accelerated
- …