Results 1  10
of
15
Range Selection and Median: Tight Cell Probe Lower Bounds and Adaptive Data Structures
"... Range selection is the problem of preprocessing an input array A of n unique integers, such that given a query (i, j, k), one can report the k’th smallest integer in the subarray A[i], A[i + 1],..., A[j]. In this paper we consider static data structures in the wordRAM for range selection and severa ..."
Abstract

Cited by 12 (5 self)
 Add to MetaCart
Range selection is the problem of preprocessing an input array A of n unique integers, such that given a query (i, j, k), one can report the k’th smallest integer in the subarray A[i], A[i + 1],..., A[j]. In this paper we consider static data structures in the wordRAM for range selection and several natural special cases thereof. The first special case is known as range median, which arises when k is fixed to ⌊(j − i + 1)/2⌋. The second case, denoted prefix selection, arises when i is fixed to 0. Finally, we also consider the bounded rank prefix selection problem and the fixed rank range selection problem. In the former, data structures must support prefix selection queries under the assumption that k ≤ κ for some value κ ≤ n given at construction time, while in the latter, data structures must support range selection queries where k is fixed beforehand for all queries. We prove cell probe lower bounds for range selection, prefix selection and range median, stating that any data structure that uses S words of space needs Ω(log n / log(Sw/n)) time to answer a query. In particular, any data structure that uses n log O(1) n space needs Ω(log n / log log n) time to answer a query, and any data structure that supports queries in constant time, needs n 1+Ω(1) space. For data structures that uses n log O(1) n space this matches the best known upper bound. Additionally, we present a linear space data structure that supports range selection queries in O(log k / log log n + log log n) time. Finally, we prove that any data structure that uses S space, needs Ω(log κ / log(Sw/n)) time to answer a bounded rank prefix selection query and Ω(log k / log(Sw/n)) time to answer a fixed rank range selection query. This shows that our data structure is optimal except for small values of k. 1
Fast and accurate estimation of shortest paths in large graphs
 In Proceedings of Conference on Information and Knowledge Management (CIKM
, 2010
"... Computing shortest paths between two given nodes is a fundamental operation over graphs, but known to be nontrivial over large diskresident instances of graph data. While a numberoftechniquesexistfor answeringreachabilityqueries and approximating node distances efficiently, determining actual short ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
Computing shortest paths between two given nodes is a fundamental operation over graphs, but known to be nontrivial over large diskresident instances of graph data. While a numberoftechniquesexistfor answeringreachabilityqueries and approximating node distances efficiently, determining actual shortest paths (i.e. the sequence of nodes involved) is often neglected. However, in applications arising in massive online social networks, biological networks, and knowledge graphs it is often essential to find out many, if not all, shortest paths between two given nodes. In this paper, we address this problem and present a scalable sketchbased index structure that not only supports estimation of node distances, but also computes corresponding shortest paths themselves. Generating the actual path information allows for further improvements to the estimation accuracy of distances (and paths), leading to nearexact shortestpath approximations in real world graphs. We evaluate our techniques – implemented within a fully functional RDF graph database system – over large realworld social and biological networks of sizes ranging from tens of thousand to millions of nodes and edges. Experiments on several datasets show that we can achieve query response times providing several orders of magnitude speedup over traditional path computations while keeping the estimation errors between 0 % and 1 % on average.
Approximate Distance Queries and Compact Routing in Sparse Graphs
"... Abstract—An approximate distance query data structure is a compact representation of a graph, and can be queried to approximate shortest paths between any pair of vertices. Any such data structure that retrieves stretch 2k−1 paths must require spaceΩ(n 1+1/k) for graphs of n nodes. The hard cases th ..."
Abstract

Cited by 7 (5 self)
 Add to MetaCart
Abstract—An approximate distance query data structure is a compact representation of a graph, and can be queried to approximate shortest paths between any pair of vertices. Any such data structure that retrieves stretch 2k−1 paths must require spaceΩ(n 1+1/k) for graphs of n nodes. The hard cases that enforce this lower bound are, however, rather dense graphs with average degreeΩ(n 1/k). We present data structures that, for sparse graphs, substantially break that lower bound barrier at the expense of higher query time. For instance, general graphs require O(n 3/2) space and constant query time for stretch 3 paths. For the realistic scenario of a graph with average degreeΘ(log n), special cases of our data structures retrieve stretch 2 paths with Õ(n 3/2) space and stretch 3 paths with Õ(n) space, albeit at the cost of Õ ( � n) query time. Moreover, supported by largescale simulations on graphs including the ASlevel Internet graph, we argue that our stretch2 scheme would be simple and efficient to implement as a distributed compact routing protocol. I.
LinearSpace Approximate Distance Oracles for Planar, BoundedGenus, and MinorFree Graphs
"... Abstract. A (1 + ɛ)approximate distance oracle for a graph is a data structure that supports approximate pointtopoint shortestpathdistance queries. The relevant measures for a distanceoracle construction are: space, query time, and preprocessing time. There are strong distanceoracle construct ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
Abstract. A (1 + ɛ)approximate distance oracle for a graph is a data structure that supports approximate pointtopoint shortestpathdistance queries. The relevant measures for a distanceoracle construction are: space, query time, and preprocessing time. There are strong distanceoracle constructions known for planar graphs (Thorup) and, subsequently, minorexcluded graphs (Abraham and Gavoille). However, these require Ω(ɛ −1 n lg n) space for nnode 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, boundedgenus graphs, and minorexcluded graphs we give distanceoracle constructions that require only
Exact Distance Oracles for Planar Graphs
, 2010
"... We provide the first linearspace data structure with provable sublinear query time for exact pointtopoint shortest path queries in planar graphs. We prove that for any planar graph G with nonnegative arc lengths and for any ɛ> 0 there is a data structure that supports exact shortest path and dist ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
We provide the first linearspace data structure with provable sublinear query time for exact pointtopoint shortest path queries in planar graphs. We prove that for any planar graph G with nonnegative arc lengths and for any ɛ> 0 there is a data structure that supports exact shortest path and distance queries in G with the following properties: the data structure can be created in time O(n lg(n) lg(1/ɛ)), the space required is O(n lg(1/ɛ)), and the query time is O(n 1/2+ɛ). Previous data structures by Fakcharoenphol and Rao (JCSS’06), Klein, Mozes, and Weimann (TransAlg’10), and Mozes and WulffNilsen (ESA’10) with query time O(n 1/2 lg 2 n) use space at least Ω(n lg n / lg lg n). We also give a construction with a more general tradeoff. We prove that for any integer S ∈ [n lg n, n 2], we can construct in time Õ(S) a data structure of size O(S) that answers distance queries in O(nS −1/2 lg 2.5 n) time per query. Cabello (SODA’06) gave a comparable construction for the smaller range S ∈ [n 4/3 lg 1/3 n, n 2]. For the range S ∈ (n lg n, n 4/3 lg 1/3 n), only data structures of size O(S) with query time O(n 2 /S) had been known (Djidjev, WG’96). Combined, our results give the best query times for any shortestpath data structure for planar graphs with space S = o(n 4/3 lg 1/3 n). As a consequence, we also obtain an algorithm that computes k–many distances in planar graphs in time O((kn) 2/3 (lg n) 2 (lg lg n) −1/3 + n(lg n) 2 / lg lg n). 1
Higher cell probe lower bounds for evaluating polynomials
 In Proc. 53rd IEEE Symposium on Foundations of Computer Science
, 2012
"... Abstract—In this paper, we study the cell probe complexity of evaluating an ndegree polynomial P over a finite field F of size at least n 1+Ω(1). More specifically, we show that any static data structure for evaluating P (x), where x ∈ F, must use Ω(lg F / lg(Sw/n lg F)) cell probes to answer a ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Abstract—In this paper, we study the cell probe complexity of evaluating an ndegree polynomial P over a finite field F of size at least n 1+Ω(1). More specifically, we show that any static data structure for evaluating P (x), where x ∈ F, must use Ω(lg F / lg(Sw/n lg F)) cell probes to answer a query, where S denotes the space of the data structure in number of cells and w the cell size in bits. This bound holds in expectation for randomized data structures with any constant error probability δ < 1/2. Our lower bound not only improves over the Ω(lg F / lg S) lower bound of Miltersen [TCS’95], but is in fact the highest static cell probe lower bound to date: For linear space (i.e. S = O(n lg F/w)), our query time lower bound simplifies to Ω(lg F), whereas the highest previous lower bound for any static data structure problem having d different queries is Ω(lg d / lg lg d), which was first achieved by Pǎtras¸cu and Thorup [SICOMP’10]. We also use the recent technique of Larsen [STOC’12] to show a lower bound of tq = Ω(lg F  lg n / lg(wtu / lg F) lg(wtu)) for dynamic data structures for polynomial evaluation over a finite field F of size Ω(n 2). Here tq denotes the expected query time and tu the worst case update time. This lower bound holds for randomized data structures with any constant error probability δ < 1/2. This is only the second time a lower bound beyond max{tu, tq} = Ω(max{lg n, lg d / lg lg d}) has been achieved for dynamic data structures, where d denotes the number of different queries and updates to the problem. Furthermore, it is the first such lower bound that holds for randomized data structures with a constant probability of error. Keywordscell probe model, lower bounds, data structures, polynomials I.
Distance Oracles for VertexLabeled Graphs
"... Abstract. Given a graph G = (V, E) with nonnegative edge lengths whose vertices are assigned a label from L = {λ1,..., λℓ}, we construct a compact distance oracle that answers queries of the form: “What is δ(v, λ)?”, where v ∈ V is a vertex in the graph, λ ∈ L a vertex label, and δ(v, λ) is the dis ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
Abstract. Given a graph G = (V, E) with nonnegative edge lengths whose vertices are assigned a label from L = {λ1,..., λℓ}, we construct a compact distance oracle that answers queries of the form: “What is δ(v, λ)?”, where v ∈ V is a vertex in the graph, λ ∈ L a vertex label, and δ(v, λ) is the distance (length of a shortest path) between v and the closest vertex labeled λ in G. We formalize this natural problem and provide a hierarchy of approximate distance oracles that require subquadratic space and return a distance of constant stretch. We also extend our solution to dynamic oracles that handle label changes in sublinear time. 1
Faster Approximate Distance Queries and Compact Routing in Sparse Graphs
, 2012
"... A distance oracle is a compact representation of the shortest distance matrix of a graph. It can be queried to retrieve approximate distances and corresponding paths between any pair of vertices. A lower bound, due to Thorup and Zwick, shows that a distance oracle that returns paths of worstcase st ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
A distance oracle is a compact representation of the shortest distance matrix of a graph. It can be queried to retrieve approximate distances and corresponding paths between any pair of vertices. A lower bound, due to Thorup and Zwick, shows that a distance oracle that returns paths of worstcase stretch (2k−1) must require spaceΩ(n 1+1/k) for graphs over n nodes. The hard cases that enforce this lower bound are, however, rather dense graphs with average degreeΩ(n 1/k). We present distance oracles that, for sparse graphs, substantially break the lower bound barrier at the expense of higher query time. For any 1≤α ≤ n, our distance oracles can return stretch 2 paths using O(m+ n 2 /α) space and stretch 3 paths using O(m+n 2 /α 2) space, at the expense of O(αm/n) query time. By setting appropriate values ofα, we get the first distance oracles that have size linear in the size of the graph, and return constant stretch paths in nontrivial query time. The query time can be further reduced to O(α), by using an additional O(mα) space for all our distance oracles, or at the cost of a small constant additive stretch. We use our stretch 2 distance oracle to design a compact routing scheme that requires Õ(n 1/2) memory at each node and, after a handshaking phase, routes along paths with worstcase stretch 2. Moreover, supported by largescale simulations on graphs including the ASlevel Internet graph, we argue that our stretch2 scheme would be simple and efficient to implement as a distributed compact routing protocol. An earlier version of this paper appeared in INFOCOM 2011[1]. The extended version presents results that improve upon the results presented in the conference version; significantly more simplified presentation and proofs for the results in the conference version; and in addition, distance oracles for unweighted graphs.
Fast, precise and dynamic distance queries
"... We present an approximate distance oracle for a point set S with n points and doubling dimension λ. For every ε> 0, the oracle supports (1 + ε)approximate distance queries in (universal) constant time, occupies space [ε −O(λ) + 2 O(λ log λ)]n, and can be constructed in [2 O(λ) log 3 n+ε −O(λ) +2 O( ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We present an approximate distance oracle for a point set S with n points and doubling dimension λ. For every ε> 0, the oracle supports (1 + ε)approximate distance queries in (universal) constant time, occupies space [ε −O(λ) + 2 O(λ log λ)]n, and can be constructed in [2 O(λ) log 3 n+ε −O(λ) +2 O(λ log λ)]n expected time. This improves upon the best previously known constructions, presented by HarPeled and Mendel [13]. Furthermore, the oracle can be made fully dynamic with expected O(1) query time and only 2O(λ) log n+ε−O(λ) O(λ log λ) +2 update time. This is the first fully dynamic (1 + ε)distance oracle. 1
Ultrametric Subsets with . . .
"... It is shown that for every ε ∈ (0, 1), every compact metric space (X, d) has a compact subset S ⊆ X that embeds into an ultrametric space with distortion O(1/ε), and dimH(S) � (1 − ε) dimH(X), where dimH(·) denotes Hausdorff dimension. The above O(1/ε) distortion estimate is shown to be sharp via ..."
Abstract
 Add to MetaCart
It is shown that for every ε ∈ (0, 1), every compact metric space (X, d) has a compact subset S ⊆ X that embeds into an ultrametric space with distortion O(1/ε), and dimH(S) � (1 − ε) dimH(X), where dimH(·) denotes Hausdorff dimension. The above O(1/ε) distortion estimate is shown to be sharp via a construction based on sequences of expander graphs.