3,338 research outputs found
A Local Algorithm for the Sparse Spanning Graph Problem
Constructing a sparse spanning subgraph is a fundamental primitive in graph
theory. In this paper, we study this problem in the Centralized Local model,
where the goal is to decide whether an edge is part of the spanning subgraph by
examining only a small part of the input; yet, answers must be globally
consistent and independent of prior queries.
Unfortunately, maximally sparse spanning subgraphs, i.e., spanning trees,
cannot be constructed efficiently in this model. Therefore, we settle for a
spanning subgraph containing at most edges (where is the
number of vertices and is a given approximation/sparsity
parameter). We achieve query complexity of
, (-notation hides
polylogarithmic factors in ). where is the maximum degree of the
input graph. Our algorithm is the first to do so on arbitrary bounded degree
graphs. Moreover, we achieve the additional property that our algorithm outputs
a spanner, i.e., distances are approximately preserved. With high probability,
for each deleted edge there is a path of
hops in the output that connects its endpoints
Non-Local Probes Do Not Help with Graph Problems
This work bridges the gap between distributed and centralised models of
computing in the context of sublinear-time graph algorithms. A priori, typical
centralised models of computing (e.g., parallel decision trees or centralised
local algorithms) seem to be much more powerful than distributed
message-passing algorithms: centralised algorithms can directly probe any part
of the input, while in distributed algorithms nodes can only communicate with
their immediate neighbours. We show that for a large class of graph problems,
this extra freedom does not help centralised algorithms at all: for example,
efficient stateless deterministic centralised local algorithms can be simulated
with efficient distributed message-passing algorithms. In particular, this
enables us to transfer existing lower bound results from distributed algorithms
to centralised local algorithms
A Local Algorithm for Constructing Spanners in Minor-Free Graphs
Constructing a spanning tree of a graph is one of the most basic tasks in
graph theory. We consider this problem in the setting of local algorithms: one
wants to quickly determine whether a given edge is in a specific spanning
tree, without computing the whole spanning tree, but rather by inspecting the
local neighborhood of . The challenge is to maintain consistency. That is,
to answer queries about different edges according to the same spanning tree.
Since it is known that this problem cannot be solved without essentially
viewing all the graph, we consider the relaxed version of finding a spanning
subgraph with edges (where is the number of vertices and
is a given sparsity parameter). It is known that this relaxed
problem requires inspecting edges in general graphs, which
motivates the study of natural restricted families of graphs. One such family
is the family of graphs with an excluded minor. For this family there is an
algorithm that achieves constant success probability, and inspects
edges (for each edge it is queried
on), where is the maximum degree in the graph and is the size of the
excluded minor. The distances between pairs of vertices in the spanning
subgraph are at most a factor of larger than in
.
In this work, we show that for an input graph that is -minor free for any
of size , this task can be performed by inspecting only edges. The distances between pairs of vertices in the spanning
subgraph are at most a factor of larger
than in . Furthermore, the error probability of the new algorithm is
significantly improved to . This algorithm can also be easily
adapted to yield an efficient algorithm for the distributed setting
Brief Announcement: A Centralized Local Algorithm for the Sparse Spanning Graph Problem
Constructing a sparse spanning subgraph is a fundamental primitive in graph theory. In this paper, we study this problem in the Centralized Local model, where the goal is to decide whether an edge is part of the spanning subgraph by examining only a small part of the input; yet, answers must be globally consistent and independent of prior queries.
Unfortunately, maximally sparse spanning subgraphs, i.e., spanning trees, cannot be constructed efficiently in this model. Therefore, we settle for a spanning subgraph containing at most (1+epsilon)n edges (where n is the number of vertices and epsilon is a given approximation/sparsity parameter). We achieve a query complexity of O(poly(Delta/epsilon)n^(2/3)) (up to polylogarithmic factors in n) where Delta is the maximum degree of the input graph. Our algorithm is the first to do so on arbitrary bounded degree graphs. Moreover, we achieve the additional property that our algorithm outputs a spanner, i.e., distances are approximately preserved. With high probability, for each deleted edge there is a path of O(log n (Delta+log n)/epsilon) hops in the output that connects its endpoints
A Local Algorithm for the Sparse Spanning Graph Problem
Constructing a sparse \emph{spanning subgraph} is a fundamental primitive in graph theory. In this paper, we study this problem in the Centralized Local model, where the goal is to decide whether an edge is part of the spanning subgraph by examining only a small part of the input; yet, answers must be globally consistent and independent of prior queries. Unfortunately, maximally sparse spanning subgraphs, i.e., spanning trees, cannot be constructed efficiently in this model. Therefore, we settle for a spanning subgraph containing at most edges (where is the number of vertices and is a given approximation/sparsity parameter). We achieve query complexity of ,\footnote{-notation hides polylogarithmic factors in .} where is the maximum degree of the input graph. Our algorithm is the first to do so on arbitrary graphs. Moreover, we achieve the additional property that our algorithm outputs a \emph{spanner,} i.e., distances are approximately preserved. With high probability, for each deleted edge there is a path of hops in the output that connects its endpoints
Visualising the structure of document search results: A comparison of graph theoretic approaches
This is the post-print of the article - Copyright @ 2010 Sage PublicationsPrevious work has shown that distance-similarity visualisation or ‘spatialisation’ can provide a potentially useful context in which to browse the results of a query search, enabling the user to adopt a simple local foraging or ‘cluster growing’ strategy to navigate through the retrieved document set. However, faithfully mapping feature-space models to visual space can be problematic owing to their inherent high dimensionality and non-linearity. Conventional linear approaches to dimension reduction tend to fail at this kind of task, sacrificing local structural in order to preserve a globally optimal mapping. In this paper the clustering performance of a recently proposed algorithm called isometric feature mapping (Isomap), which deals with non-linearity by transforming dissimilarities into geodesic distances, is compared to that of non-metric multidimensional scaling (MDS). Various graph pruning methods, for geodesic distance estimation, are also compared. Results show that Isomap is significantly better at preserving local structural detail than MDS, suggesting it is better suited to cluster growing and other semantic navigation tasks. Moreover, it is shown that applying a minimum-cost graph pruning criterion can provide a parameter-free alternative to the traditional K-neighbour method, resulting in spatial clustering that is equivalent to or better than that achieved using an optimal-K criterion
A Centralized Local Algorithm for the Sparse Spanning Graph Problem
Constructing a sparse spanning subgraph is a fundamental primitive in graph theory. In this paper, we study this problem in the Centralized Local model, where the goal is to decide whether an edge is part of the spanning subgraph by examining only a small part of the input; yet, answers must be globally consistent and independent of prior queries.
Unfortunately, maximally sparse spanning subgraphs, i.e., spanning trees, cannot be constructed efficiently in this model. Therefore, we settle for a spanning subgraph containing at most (1+epsilon)n edges (where n is the number of vertices and epsilon is a given approximation/sparsity parameter). We achieve a query complexity of O~(poly(Delta/epsilon)n^{2/3}), where Delta is the maximum degree of the input graph. Our algorithm is the first to do so on arbitrary bounded degree graphs. Moreover, we achieve the additional property that our algorithm outputs a spanning subgraph of bounded stretch i.e., distances are approximately preserved. With high probability, for each deleted edge there is a path of O(log n * (Delta+log n)/epsilon) hops in the output that connects its endpoints
- …