Results 11  20
of
30
Finger Search Trees with Constant Insertion Time
 In Proc. 9th Annual ACMSIAM Symposium on Discrete Algorithms
, 1997
"... We consider the problem of implementing finger search trees on the pointer machine, i.e., how to maintain a sorted list such that searching for an element x, starting the search at any arbitrary element f in the list, only requires logarithmic time in the distance between x and f in the list. We pr ..."
Abstract

Cited by 14 (3 self)
 Add to MetaCart
(Show Context)
We consider the problem of implementing finger search trees on the pointer machine, i.e., how to maintain a sorted list such that searching for an element x, starting the search at any arbitrary element f in the list, only requires logarithmic time in the distance between x and f in the list. We present the first pointerbased implementation of finger search trees allowing new elements to be inserted at any arbitrary position in the list in worst case constant time. Previously, the best known insertion time on the pointer machine was O(log n), where n is the total length of the list. On a unitcost RAM, a constant insertion time has been achieved by Dietz and Raman by using standard techniques of packing small problem sizes into a constant number of machine words. Deletion of a list element is supported in O(log n) time, which matches the previous best bounds. Our data structure requires linear space. 1 Introduction A finger search tree is a data structure which stores a sorte...
Binary Search Trees of Almost Optimal Height
 ACTA INFORMATICA
, 1990
"... First we present a generalization of symmetric binary Btrees, SBB(k) trees. The obtained structure has a height of only \Sigma (1 + 1k) log(n + 1)\Upsilon, where k may be chosen to be any positive integer. The maintenance algorithms require only a constant number of rotations per updating operati ..."
Abstract

Cited by 11 (1 self)
 Add to MetaCart
First we present a generalization of symmetric binary Btrees, SBB(k) trees. The obtained structure has a height of only \Sigma (1 + 1k) log(n + 1)\Upsilon, where k may be chosen to be any positive integer. The maintenance algorithms require only a constant number of rotations per updating operation in the worst case. These properties together with the fact that the structure is relatively simple to implement makes it a useful alternative to other search trees in practical applications. Then, by using an SBB(k)tree with a varying k we achieve a structure with a logarithmic amortized cost per update and a height of log n + o(log n). This result is an improvement of the upper bound on the height of a dynamic binary search tree. By maintaining two trees simultaneously the amortized cost is transformed into a worstcase cost. Thus, we have improved the worstcase complexity of the dictionary problem.
Ranksensitive data structures
 In Proc. 12th International Symposium on String Processing and Information Retrieval (SPIRE), LNCS v. 3772
, 2005
"... Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we foc ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we focus on ranksensitive data structures, which are additionally given a ranking of the n items, so that just the top k bestranking items should be reported at query time, sorted in rank order, at a cost of O(t(n) + k) time. Note that k is part of the query as a parameter under the control of the user (as opposed to ℓ which is querydependent). We explore the problem of adding ranksensitivity to data structures such as suffix trees or range trees, where the ℓ items satisfying the query form O(polylog(n)) intervals of consecutive entries from which we choose the top k bestranking ones. Letting s(n) be the number of items (including their copies) stored in the original data structures, we increase the space by an additional term of O(s(n) lg ǫ n) memory words of space, each of O(lg n) bits, for any positive constant ǫ < 1. We allow for changing the ranking on the fly during the lifetime of the data structures, with ranking values in 0... O(n). In this case, query time becomes O(t(n)+k) plus O(lg n/lg lg n) per interval; each change in the ranking and each insertion/deletion of an item takes O(lg n) time; the additional term in space occupancy increases to O(s(n) lg n/lg lg n). 1
Jaywalking your Dog  Computing the Fréchet Distance with Shortcuts
, 2011
"... The similarity of two polygonal curves can be measured using the Fréchet distance. We introduce the notion of a more robust Fréchet distance, where one is allowed to shortcut between vertices of one of the curves. This is a natural approach for handling noise, in particular batched outliers. We comp ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
The similarity of two polygonal curves can be measured using the Fréchet distance. We introduce the notion of a more robust Fréchet distance, where one is allowed to shortcut between vertices of one of the curves. This is a natural approach for handling noise, in particular batched outliers. We compute a constant factor approximation to the minimum Fréchet distance over all possible such shortcuts. Our algorithm runs in O(c² kn log³ n) time if one is allowed to take at most k shortcuts and the input curves are cpacked. For the case where the number of shortcuts is unrestricted, we describe an algorithm which runs in O(c² n log³ n) time. To facilitate the new algorithm we develop several new datastructures, which we believe to be of independent interest: (i) for range reporting on a curve, and (ii) for preprocessing a curve to answer queries for the Fréchet distance between a subcurve and a line segment.
Fully Dynamic Transitive Closure in Plane Dags with One Source and One Sink
, 1994
"... We give an algorithm for the Dynamic Transitive Closure Problem for planar directed acyclic graphs with one source and one sink. The graph can be updated in logarithmic time under arbitrary edge insertions and deletions that preserve the embedding. Queries of the form `is there a directed path from ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
We give an algorithm for the Dynamic Transitive Closure Problem for planar directed acyclic graphs with one source and one sink. The graph can be updated in logarithmic time under arbitrary edge insertions and deletions that preserve the embedding. Queries of the form `is there a directed path from u to v?' for arbitrary vertices u and v can be answered in logarithmic time. The size of the data structure and the initialisation time are linear in the number of edges. We also give a lower bound of###26 n/ log log n) on the amortised complexity of the problem in the cell probe model with logarithmic word size.
Cryptographic Accumulators for Authenticated Hash Tables
, 2009
"... Hash tables are fundamental data structures that optimally answer membership queries. Suppose a client stores n elements in a hash table that is outsourced at a remote server. Authenticating the hash table functionality, i.e., verifying the correctness of queries answered by the server and ensuring ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Hash tables are fundamental data structures that optimally answer membership queries. Suppose a client stores n elements in a hash table that is outsourced at a remote server. Authenticating the hash table functionality, i.e., verifying the correctness of queries answered by the server and ensuring the integrity of the stored data, is crucial because the server, lying outside the administrative control of the client, can be malicious. We design efficient and secure protocols for optimally authenticating (non)membership queries on hash tables, using cryptographic accumulators as our basic security primitive and applying them in a novel hierarchical way over the stored data. We provide the first construction for authenticating a hash table with constant query cost and sublinear update cost, strictly improving upon previous methods. Our first solution, based on the RSA accumulator, allows the server to provide a proof of integrity of the answer to a membership query in constant time and supports updates in O (n ǫ log n) time for any fixed constant 0 < ǫ < 1, yet keeping the communication and verification costs constant. It also lends itself to a scheme that achieves different tradeoffs—namely,
Kinetic Medians and ��Trees
"... Abstract. We propose algorithms for maintaining two variants of ��trees of a set of moving points in the plane. A pseudo ��tree allows the number of points stored in the two children to differ by a constant factor. An overlapping ��tree allows the bounding boxes of two children to overlap. We sho ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. We propose algorithms for maintaining two variants of ��trees of a set of moving points in the plane. A pseudo ��tree allows the number of points stored in the two children to differ by a constant factor. An overlapping ��tree allows the bounding boxes of two children to overlap. We show that both of them support range search operations in Ç Ò time, where ¯ only depends on the approximation precision. As the points move, we use eventbased kinetic data structures to update the tree when necessary. Both trees undergo only a quadratic number of events, which is optimal, and the update cost for each event is only polylogarithmic. To maintain the pseudo ��tree, we develop algorithms for computing an approximate median level of a line arrangement, which itself is of great interest. We show that the computation of the approximate median level of a set of lines or line segments can be done in an online fashion smoothly, i.e., there are no expensive updates for any events. For practical consideration, we study the case in which there are speedlimit restrictions or smooth trajectory requirements. The maintenance of the pseudo ��tree, as a consequence of the approximate median algorithm, can also adapt to those restrictions. 1
Competitive TreeStructured Dictionaries
"... In this note we describe a general technique for making treestructured dynamic dictionaries adapt to be competitive with the most efficient implementation, by using potential energy parameters and a simple partial rebuilding scheme. Introduction. Online algorithms deal with optimizing the performan ..."
Abstract
 Add to MetaCart
(Show Context)
In this note we describe a general technique for making treestructured dynamic dictionaries adapt to be competitive with the most efficient implementation, by using potential energy parameters and a simple partial rebuilding scheme. Introduction. Online algorithms deal with optimizing the performance of operation sequences (e.g., see [4, 9]). Such algorithms are desired to be ¡competitive [4], for some parameter ¡ ¢ £ , where ¡ is an upper bound on the ratio of the costs of the solution defined by the online algorithm
Abstract
, 2005
"... Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. ..."
Abstract
 Add to MetaCart
Questions about order versus disorder in systems and models have been fascinating scientists over the years. In Computer Science, order is intimately related to sorting, commonly meant as the task of arranging keys in increasing or decreasing order with respect to an underlying total order relation. The sorted organization is amenable for searching a set of n keys, since each search requires Θ(log n) comparisons in the worst case, which is optimal if the cost of a single comparison can be considered a constant. Nevertheless, we prove that disorder implicitly provides more information than order does. For the general case of searching an array of multidimensional keys, whose comparison cost is proportional to their length (and hence cannot be considered a constant), we demonstrate that “suitable ” disorder gives better bounds than those derivable by using the natural lexicographic order. We start out from previous work done by Andersson, Hagerup, H˚astad and Petersson [SIAM Journal on Computing, 30(2), 2001], who proved that k log log n