Results 1  10
of
12
Instanceoptimal geometric algorithms
"... ... in 2d and 3d, and offline point location in 2d. We prove the existence of an algorithm A for computing 2d or 3d convex hulls that is optimal for every point set in the following sense: for every set S of n points and for every algorithm A ′ in a certain class A, the maximum running time of ..."
Abstract

Cited by 17 (2 self)
 Add to MetaCart
... in 2d and 3d, and offline point location in 2d. We prove the existence of an algorithm A for computing 2d or 3d convex hulls that is optimal for every point set in the following sense: for every set S of n points and for every algorithm A ′ in a certain class A, the maximum running time of A on input 〈s1,..., sn〉 is at most a constant factor times the maximum running time of A ′ on 〈s1,..., sn〉, where the maximum is taken over all permutations 〈s1,..., sn 〉 of S. In fact, we can establish a stronger property: for every S and A ′ , the maximum running time of A is at most a constant factor times the average running time of A ′ over all permutations of S. We call algorithms satisfying these properties instanceoptimal in the orderoblivious and randomorder setting. Such instanceoptimal algorithms simultaneously subsume outputsensitive algorithms and distributiondependent averagecase algorithms, and all algorithms that do not take advantage of the order of the input or that assume the input is given in a random order. The class A under consideration consists of all algorithms in a decision tree model where the tests involve only multilinear functions with a constant number of arguments. To establish an instancespecific lower bound, we deviate from traditional Ben–Orstyle proofs and adopt an interesting adversary argument. For 2d convex hulls, we prove that a version of the well known algorithm by Kirkpatrick and Seidel (1986) or Chan, Snoeyink, and Yap (1995) already attains this lower bound. For 3d convex hulls, we propose a new algorithm. To demonstrate the potential of the concept, we further obtain instanceoptimal results for a few other standard problems in computational geometry, such as maxima in 2d and 3d, orthogonal line segment intersection in 2d, finding bichromatic L∞close pairs in 2d, offline orthogonal range searching in 2d, offline dominance reporting in 2d and 3d, offline halfspace range reporting 1.
Applications of forbidden 01 matrices to search tree and path compression based data structures
, 2009
"... In this paper we improve, reprove, and simplify a variety of theorems concerning the performance of data structures based on path compression and search trees. We apply a technique very familiar to computational geometers but still foreign to many researchers in (nongeometric) algorithms and data s ..."
Abstract

Cited by 6 (5 self)
 Add to MetaCart
(Show Context)
In this paper we improve, reprove, and simplify a variety of theorems concerning the performance of data structures based on path compression and search trees. We apply a technique very familiar to computational geometers but still foreign to many researchers in (nongeometric) algorithms and data structures, namely, to bound the complexity of an object via its forbidden substructures. To analyze an algorithm or data structure in the forbidden substructure framework one proceeds in three discrete steps. First, one transcribes the behavior of the algorithm as some combinatorial object M; for example, M may be a graph, sequence, permutation, matrix, set system, or tree. (The size of M should ideally be linear in the running time.) Second, one shows that M excludes some forbidden substructure P, and third, one bounds the size of any object avoiding this substructure. The power of this framework derives from the fact that M lies in a more pristine environment and that upper bounds on the size of a Pfree object M may be reused in different contexts. All of our proofs begin by transcribing the individual operations of a dynamic data structure
6.897: Advanced data structures (Spring 2005), Lecture 3, February 8
, 2005
"... Recall from last lecture that we are looking at the documentretrieval problem. The problem can be stated as follows: Given a set of texts T1, T2,..., Tk and a pattern P, determine the distinct texts in which the patterns occurs. In particular, we are allowed to preprocess the texts in order to be a ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
Recall from last lecture that we are looking at the documentretrieval problem. The problem can be stated as follows: Given a set of texts T1, T2,..., Tk and a pattern P, determine the distinct texts in which the patterns occurs. In particular, we are allowed to preprocess the texts in order to be able to answer the query faster. Our preprocessing choice was the use of a single suffix tree, in which all the suffixes of all the texts appear, each suffix ending with a distinct symbol that determines the text in which the suffix appears. In order to answer the query we reduced the problem to rangemin queries, which in turn was reduced to the least common ancestor (LCA) problem on the cartesian tree of an array of numbers. The cartesian tree is constructed recursively by setting its root to be the minimum element of the array and recursively constructing its two subtrees using the left and right partitions of the array. The rangemin query of an interval [i, j] is then equivalent to finding the LCA of the two nodes of the cartesian tree that correspond to i and j. In this lecture we continue to see how we can solve the LCA problem on any static tree. This will involve a reduction of the LCA problem back to the rangemin query problem (!) and then a
An O(log log n)competitive binary search tree with optimal worstcase access times
"... We present the zipper tree, the first O(log log n)competitive online binary search tree that performs each access in O(log n) worstcase time. This shows that for binary search trees, optimal worstcase access time and nearoptimal amortized access time can be guaranteed simultaneously. ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
We present the zipper tree, the first O(log log n)competitive online binary search tree that performs each access in O(log n) worstcase time. This shows that for binary search trees, optimal worstcase access time and nearoptimal amortized access time can be guaranteed simultaneously.
Deamortizing Binary Search Trees
 In Automata, Languages, and Programming  39th International Colloquium, ICALP 2012
"... We present a general method for deamortizing essentially any Binary Search Tree (BST) algorithm. In particular, by transforming Splay Trees, our method produces a BST that has the same asymptotic cost as Splay Trees on any access sequence while performing each search in O(log n) worst case time. By ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
We present a general method for deamortizing essentially any Binary Search Tree (BST) algorithm. In particular, by transforming Splay Trees, our method produces a BST that has the same asymptotic cost as Splay Trees on any access sequence while performing each search in O(log n) worst case time. By transforming MultiSplay Trees, we obtain a BST that is O(log log n) competitive, satisfies the scanning theorem, the static optimality theorem, the static finger theorem, the working set theorem, and performs each search in O(log n) worst case time. Moreover, we prove that if there is a dynamically optimal BST algorithm, then there is a dynamically optimal BST algorithm that answers every search in O(log n) worst case time.
Adaptive Binary Search Trees
, 2009
"... A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the wors ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
A ubiquitous problem in the field of algorithms and data structures is that of searching for an element from an ordered universe. The simple yet powerful binary search tree (BST) model provides a rich family of solutions to this problem. Although BSTs require Ω(lg n) time per operation in the worst case, various adaptive BST algorithms are capable of exploiting patterns in the sequence of queries to achieve tighter, inputsensitive, bounds that can be o(lg n) in many cases. This thesis furthers our understanding of what is achievable in the BST model along two directions. First, we make progress in improving instancespecific lower bounds in the BST model. In particular, we introduce a framework for generating lower bounds on the cost that any BST algorithm must pay to execute a query sequence,
Finding Maximum Degrees in Hidden Bipartite Graphs
, 2010
"... An (edge) hidden graph is a graph whose edges are not explicitly given. Detecting the presence of an edge requires expensive edgeprobing queries. We consider thek most connected vertex problem on hidden bipartite graphs. Specifically, given a bipartite graph G with independent vertex sets B and W, t ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
An (edge) hidden graph is a graph whose edges are not explicitly given. Detecting the presence of an edge requires expensive edgeprobing queries. We consider thek most connected vertex problem on hidden bipartite graphs. Specifically, given a bipartite graph G with independent vertex sets B and W, the goal is to find the k vertices in B with the largest degrees using the minimum number of queries. This problem can be regarded as a topk extension of a semijoin, and is encountered in many applications in practice (e.g., topk spatial join with arbitrarily complex join predicates). If B and W have n and m vertices respectively, the number of queries needed to solve the problem isnm in the worst case. This, however, is a pessimistic estimate on how many queries are necessary on practical data. In fact, on some easy inputs, the problem can be efficiently settled with onlykm+n edges, which is significantly
Upper Bounds for Maximally Greedy Binary Search Trees
, 2011
"... At SODA 2009, Demaine et al. presented a novel connection between binary search trees (BSTs) and subsets of points on the plane. This connection was independently discovered by Derryberry et al. As part of their results, Demaine et al. considered GreedyFuture, an offline BST algorithm that greedil ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
At SODA 2009, Demaine et al. presented a novel connection between binary search trees (BSTs) and subsets of points on the plane. This connection was independently discovered by Derryberry et al. As part of their results, Demaine et al. considered GreedyFuture, an offline BST algorithm that greedily rearranges the search path to minimize the cost of future searches. They showed that GreedyFuture is actually an online algorithm in their geometric view, and that there is a way to turn GreedyFuture into an online BST algorithm with only a constant factor increase in total search cost. Demaine et al. conjectured this algorithm was dynamically optimal, but no upper bounds were given in their paper. We prove the first nontrivial upper bounds for the cost of search operations using GreedyFuture including giving an access lemma similar to that found in Sleator and Tarjan’s classic paper on splay trees.
A Selfadjusting Data Structure for Multidimensional Point Sets ⋆
"... Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known e ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. A data structure is said to be selfadjusting if it dynamically reorganizes itself to adapt to the pattern of accesses. Efficiency is typically measured in terms of amortized complexity, that is, the average running time of an access over an arbitrary sequence of accesses. The best known example of such a data structure is Sleator and Tarjan’s splay tree. In this paper, we introduce a selfadjusting data structure for storing multidimensional point data. The data structure is based on a quadtreelike subdivision of space. Like a quadtree, the data structure implicitly encodes a subdivision of space into cells of constant combinatorial complexity. Each cell is either a quadtree box or the settheoretic difference of two such boxes. Similar to the traditional splay tree, accesses are based on an splaying operation that restructures the tree in order to bring an arbitrary internal node to the root of the tree. We show that many of the properties enjoyed by traditional splay trees can be generalized to this multidimensional version.