Results 11  20
of
41
EFFICIENT AND ERRORCORRECTING DATA STRUCTURES FOR MEMBERSHIP AND POLYNOMIAL EVALUATION
 SUBMITTED TO THE SYMPOSIUM ON THEORETICAL ASPECTS OF COMPUTER SCIENCE
"... We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “ ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “don’t know.” Furthermore, if there is no noise on the data structure, it answers all queries correctly with high probability. Our model is the common generalization of an errorcorrecting data structure model proposed recently by de Wolf, and the notion of “relaxed locally decodable codes” developed in the PCP literature. We measure the efficiency of a data structure in terms of its length (the number of bits in its representation), and queryanswering time, measured by the number of bitprobes to the (possibly corrupted) representation. We obtain results for the following two data structure problems: • (Membership) Store a subset S of size at most s from a universe of size n such that membership queries can be answered efficiently, i.e., decide if a given element from the universe is in S. We construct an errorcorrecting data structure for this problem with length nearly linear in s log n that answers membership queries with O(1) bitprobes. This nearly matches the asymptotically optimal parameters for the noiseless case: length O(s log n) and one bitprobe, due to
The limits of buffering: A tight lower bound for dynamic membership in the external memory model
 In Proc. ACM Symposium on Theory of Computing
, 2010
"... We study the dynamic membership (or dynamic dictionary) problem, which is one of the most fundamental problems in data structures. We study the problem in the external memory model with cell size b bits and cache size m bits. We prove that if the amortized cost of updates is at most 0.999 (or any ot ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
(Show Context)
We study the dynamic membership (or dynamic dictionary) problem, which is one of the most fundamental problems in data structures. We study the problem in the external memory model with cell size b bits and cache size m bits. We prove that if the amortized cost of updates is at most 0.999 (or any other constant < 1), then the query cost must be Ω(logb log n (n/m)), where n is the number of elements in the dictionary. In contrast, when the update time is allowed to be 1 + o(1), then a bit vector or hash table give query time O(1). Thus, this is a threshold phenomenon for data structures. This lower bound answers a folklore conjecture of the external memory community. Since almost any data structure task can solve membership, our lower bound implies a dichotomy between two alternatives: (i) make the amortized update time at least 1 (so the data structure does not buffer, and we lose one of the main potential advantages of the cache), or (ii) make the query time at least roughly logarithmic in n. Our result holds even when the updates and queries are chosen uniformly at random and there are no deletions; it holds for randomized data structures, holds when the universe size is O(n), and does not make any restrictive assumptions such as indivisibility. All of the lower bounds we prove hold regardless of the space consumption of the data structure, while the upper bounds only need linear space. The lower bound has some striking implications for external memory data structures. It shows that the query complexities of many problems such as 1Drange counting, predecessor, rankselect, and many others, are all the same
EntropyBounded Representation of Point Grids
"... Abstract. We give the first fully compressed representation of a set of m points on an n×n grid, taking H +o(H) bits of space, where H = lg ( n 2) m is the entropy of the set. This representation supports range counting, range reporting, and point selection queries, with a performance that is compar ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We give the first fully compressed representation of a set of m points on an n×n grid, taking H +o(H) bits of space, where H = lg ( n 2) m is the entropy of the set. This representation supports range counting, range reporting, and point selection queries, with a performance that is comparable to that of uncompressed structures and that improves upon the only previous compressed structure. Operating within entropybounded space opens a new line of research on an otherwise wellstudied area, and is becoming extremely important for handling large datasets. 1
Sorted Range Reporting
"... Abstract. In this paper we consider a variant of the orthogonal range reporting problem when all points should be reported in the sorted order of their xcoordinates. We show that reporting twodimensional points with this additional condition can be organized (almost) as efficiently as the standard ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. In this paper we consider a variant of the orthogonal range reporting problem when all points should be reported in the sorted order of their xcoordinates. We show that reporting twodimensional points with this additional condition can be organized (almost) as efficiently as the standard range reporting. Moreover, our results generalize and improve the previously known results for the orthogonal range successor problem and can be used to obtain better solutions for some stringology problems. 1
Connectivity Oracles for Failure Prone Graphs ∗
"... Dynamic graph connectivity algorithms have been studied for many years, but typically in the most general possible setting, where the graph can evolve in completely arbitrary ways. In this paper we consider a dynamic subgraph model. We assume there is some fixed, underlying graph that can be preproc ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Dynamic graph connectivity algorithms have been studied for many years, but typically in the most general possible setting, where the graph can evolve in completely arbitrary ways. In this paper we consider a dynamic subgraph model. We assume there is some fixed, underlying graph that can be preprocessed ahead of time. The graph is subject only to vertices and edges flipping “off ” (failing) and “on ” (recovering), where queries naturally apply to the subgraph on edges/vertices currently flipped on. This model fits most real world scenarios, where the topology of the graph in question (say a router network or road network) is constantly evolving due to temporary failures but never deviates too far from the ideal failurefree state. We present the first efficient connectivity oracle for graphs susceptible to vertex failures. Given vertices u and v and a set D of d failed vertices, we can determine if there is a path from u to v avoiding D in time polynomial in d log n. There is a tradeoff in our oracle between the space, which is roughly mn ɛ, for 0 < ɛ ≤ 1, and the polynomial query time, which depends on ɛ. If one wanted to achieve the same functionality with existing data structures (based on edge failures or twin vertex failures) the resulting connectivity oracle would either need exorbitant space (Ω(n d)) or update time Ω(dn), that is, linear in the number of vertices. Our connectivity oracle is therefore the first of its kind. As a byproduct of our oracle for vertex failures we reduce the problem of constructing an edgefailure oracle to 2D range searching over the integers. We show there is an Õ(m)space oracle that processes any set of d failed edges in O(d 2 log log n) time and, thereafter, answers connectivity queries in O(log log n) time. Our update time is exponentially faster than a recent connectivity oracle of Pǎtra¸scu and Thorup for bounded d, but slower as a function of d.
Nearoptimal range reporting structures for categorical data
 In Proc. 24th ACM/SIAM Symposium on Discrete Algorithms
, 2013
"... Range reporting on categorical (or colored) data is a wellstudied generalization of the classical range reporting problem in which each of the N input points has an associated color (category). A query then asks to report the set of colors of the points in a given rectangular query range, which may ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Range reporting on categorical (or colored) data is a wellstudied generalization of the classical range reporting problem in which each of the N input points has an associated color (category). A query then asks to report the set of colors of the points in a given rectangular query range, which may be far smaller than the set of all points in the query range. We study twodimensional categorical range reporting in both the wordRAM and I/Omodel. For the I/Omodel, we present two alternative data structures for threesided queries. The first answers queries in optimal O(lgB N + K/B) I/Os using O(N lg ∗ N) space, where K is the number of distinct colors in the output, B is the disk block size, and lg ∗ N is the iterated logarithm of N. Our second data structure uses linear space and answers queries in O(lgB N + lg (h) N + K/B) I/Os for any constant integer h ≥ 1. Here lg (1) N = lg N and lg (h) N = lg(lg (h−1) N) when h> 1. Both solutions use only comparisons on the coordinates. We also show that the lgB N terms in the query costs can be reduced to optimal lg lgB U when the input points lie on a U × U grid and we allow wordlevel manipulations of the coordinates. We further reduce the query time to just O(1) if the points are given on an N × N grid. Both solutions also lead to improved data structures for foursided queries. For the wordRAM, we obtain optimal data structures for threesided range reporting, as well as improved upper bounds for foursided range reporting. Finally, we show a tight lower bound on onedimensional categorical range counting using an elegant reduction from (standard) twodimensional range counting. 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
(Show Context)
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.
Efficient IP table lookup via adaptive stratified trees with selective reconstructions
 12TH EUROPEAN SYMP ON ALGORITHMS
, 2004
"... IP address lookup is a critical operation for high bandwidth routers in packet switching networks such as Internet. The lookup is a nontrivial operation since it requires searching for the longest prefix, among those stored in a (large) given table, matching the IP address. Ever increasing routing ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
IP address lookup is a critical operation for high bandwidth routers in packet switching networks such as Internet. The lookup is a nontrivial operation since it requires searching for the longest prefix, among those stored in a (large) given table, matching the IP address. Ever increasing routing tables size, traffic volume and links speed demand new and more efficient algorithms. Moreover, the imminent move to IPv6 128bit addresses will soon require a rethinking of previous technical choices. This article describes a the new data structure for solving the IP table look up problem christened the Adaptive Stratified Tree (AST). The proposed solution is based on casting the problem in geometric terms and on repeated application of efficient local geometric optimization routines. Experiments with this approach have shown that in terms of storage, query time and update time the AST is at a par with state of the art algorithms based on data compression or string manipulations (and often it is better on some of the measured quantities).
Hashed Patricia Trie: Efficient Longest Prefix Matching in PeertoPeer Systems
"... Abstract. The design of efficient search structures for peertopeer systems has attracted a lot of attention in recent years. In this paper we address the problem of longest prefix matching and present an efficient data structure called hashed Patricia trie. Our hashed Patricia trie supports Prefix ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. The design of efficient search structures for peertopeer systems has attracted a lot of attention in recent years. In this paper we address the problem of longest prefix matching and present an efficient data structure called hashed Patricia trie. Our hashed Patricia trie supports Prefixsearch(x) and Insert(x) in O(log x) hash table accesses and Delete(x) in O(1) hash table accesses when x  is the number of bits used to encode x. That is the costs only depend on x  and not the size of the data structure. The hash table accesses may be realized by any distributed hash table (DHT). 1
Adaptive and Approximate Orthogonal Range Counting
"... We present three new results on one of the most basic problems in geometric data structures, 2D orthogonal range counting. All the results are in the wbit word RAM model. • It is well known that there are linearspace data structures for 2D orthogonal range counting with worstcase optimal query t ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We present three new results on one of the most basic problems in geometric data structures, 2D orthogonal range counting. All the results are in the wbit word RAM model. • It is well known that there are linearspace data structures for 2D orthogonal range counting with worstcase optimal query time O(logw n). We give an O(n log log n)space adaptive data structure that improves the query time to O(log log n + logw k), where k is the output count. When k = O(1), our bounds match the state of the art for the 2D orthogonal range emptiness problem [Chan, Larsen, and Pătra¸scu, SoCG 2011]. • We give an O(n log log n)space data structure for approximate 2D orthogonal range counting that can compute a (1 + δ)factor approximation to the count in O(log log n) time for any fixed constant δ> 0. Again, our bounds match the state of the art for the 2D orthogonal range emptiness problem. • Lastly, we consider the 1D range selection problem, where a query in an array involves finding the kth least element in a given subarray. This problem is closely related to 2D 3sided orthogonal range counting. Recently, Jørgensen and Larsen [SODA 2011] presented a linearspace adaptive data structure with query time O(log log n + log w k). We give a new linearspace structure that improves the query time to O(1 + log w k), exactly matching the lower bound proved by Jørgensen and Larsen.