Results 1  10
of
11
Nearest Common Ancestors: A survey and a new distributed algorithm
, 2002
"... Several papers describe linear time algorithms to preprocess a tree, such that one can answer subsequent nearest common ancestor queries in constant time. Here, we survey these algorithms and related results. A common idea used by all the algorithms for the problem is that a solution for complete ba ..."
Abstract

Cited by 76 (12 self)
 Add to MetaCart
Several papers describe linear time algorithms to preprocess a tree, such that one can answer subsequent nearest common ancestor queries in constant time. Here, we survey these algorithms and related results. A common idea used by all the algorithms for the problem is that a solution for complete balanced binary trees is straightforward. Furthermore, for complete balanced binary trees we can easily solve the problem in a distributed way by labeling the nodes of the tree such that from the labels of two nodes alone one can compute the label of their nearest common ancestor. Whether it is possible to distribute the data structure into short labels associated with the nodes is important for several applications such as routing. Therefore, related labeling problems have received a lot of attention recently.
Succinct ordinal trees with levelancestor queries
 In SODA ’04: Proceedings of the Fifteenth annual ACMSIAM Symposium on Discrete Algorithms
, 2004
"... We consider succinct or spaceefficient representations of trees that efficiently support a variety of navigation operations. We focus on static ordinal trees, i.e., arbitrary static rooted trees where the children of each node are ordered. The set of operations is essentially the union of the sets ..."
Abstract

Cited by 41 (4 self)
 Add to MetaCart
We consider succinct or spaceefficient representations of trees that efficiently support a variety of navigation operations. We focus on static ordinal trees, i.e., arbitrary static rooted trees where the children of each node are ordered. The set of operations is essentially the union of the sets of operations supported by previous succinct
The Level Ancestor Problem Simplified
"... We present a very simple algorithm for the Level Ancestor Problem. A Level Ancestor Query LA(v; d) requests the depth d ancestor of node v. The Level Ancestor Problem is thus: preprocess a given rooted tree T to answer level ancestor queries. While optimal solutions to this problem already exist ..."
Abstract

Cited by 38 (0 self)
 Add to MetaCart
We present a very simple algorithm for the Level Ancestor Problem. A Level Ancestor Query LA(v; d) requests the depth d ancestor of node v. The Level Ancestor Problem is thus: preprocess a given rooted tree T to answer level ancestor queries. While optimal solutions to this problem already exist, our new optimal solution is simple enough to be taught and implemented.
Improved Algorithms for Finding Level Ancestors in Dynamic Trees
 Automata, Languages and Programming, 27th International Colloquium, ICALP 2000, number 1853 in LNCS
, 2000
"... Given a node x at depth d in a rooted tree LevelAncestor(x; i) returns the ancestor to x in depth d i. We show how to maintain a tree under addition of new leaves so that updates and level ancestor queries are being performed in worst case constant time. Given a forest of trees with n nodes wher ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
Given a node x at depth d in a rooted tree LevelAncestor(x; i) returns the ancestor to x in depth d i. We show how to maintain a tree under addition of new leaves so that updates and level ancestor queries are being performed in worst case constant time. Given a forest of trees with n nodes where edges can be added, m queries and updates take O(m(m;n)) time. This solves two open problems (P.F.
Confluently Persistent Deques via DataStructural Bootstrapping
 J. of Algorithms
, 1993
"... We introduce datastructural bootstrapping, a technique to design data structures recursively, and use it to design confluently persistent deques. Our data structure requires O(log 3 k) worstcase time and space per deletion, where k is the total number of deque operations, and constant worstcase t ..."
Abstract

Cited by 15 (4 self)
 Add to MetaCart
We introduce datastructural bootstrapping, a technique to design data structures recursively, and use it to design confluently persistent deques. Our data structure requires O(log 3 k) worstcase time and space per deletion, where k is the total number of deque operations, and constant worstcase time and space for other operations. Further, the data structure allows a purely functional implementation, with no side effects. This improves a previous result of Driscoll, Sleator, and Tarjan. 1 An extended abstract of this paper was presented at the 4th ACMSIAM Symposium on Discrete Algorithms, 1993. 2 Supported by a Fannie and John Hertz Foundation fellowship, National Science Foundation Grant No. CCR8920505, and the Center for Discrete Mathematics and Theoretical Computer Science (DIMACS) under NSFSTC8809648. 3 Also affiliated with NEC Research Institute, 4 Independence Way, Princeton, NJ 08540. Research at Princeton University partially supported by the National Science Foundatio...
Perfect hashing for strings: Formalization and Algorithms
 IN PROC 7TH CPM
, 1996
"... Numbers and strings are two objects manipulated by most programs. Hashing has been wellstudied for numbers and it has been effective in practice. In contrast, basic hashing issues for strings remain largely unexplored. In this paper, we identify and formulate the core hashing problem for strings th ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
Numbers and strings are two objects manipulated by most programs. Hashing has been wellstudied for numbers and it has been effective in practice. In contrast, basic hashing issues for strings remain largely unexplored. In this paper, we identify and formulate the core hashing problem for strings that we call substring hashing. Our main technical results are highly efficient sequential/parallel (CRCW PRAM) Las Vegas type algorithms that determine a perfect hash function for substring hashing. For example, given a binary string of length n, one of our algorithms finds a perfect hash function in O(log n) time, O(n) work, and O(n) space; the hash value for any substring can then be computed in O(log log n) time using a single processor. Our approach relies on a novel use of the suffix tree of a string. In implementing our approach, we design optimal parallel algorithms for the problem of determining weighted ancestors on a edgeweighted tree that may be of independent interest.
Dynamic Tree Cross Products
 In: Proc. 15th ISAAC. LNCS. (2004
, 2004
"... Range searching over tree cross products is a variant of classic range searching, recently introduced by Buchsbaum et al. (Proc. 8th ESA, vol. 1879 of LNCS, pp. 120131, 2000). A tree cross product consist of hyperedges connecting the nodes of trees T1 , . . . , Td . In this context, range sear ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Range searching over tree cross products is a variant of classic range searching, recently introduced by Buchsbaum et al. (Proc. 8th ESA, vol. 1879 of LNCS, pp. 120131, 2000). A tree cross product consist of hyperedges connecting the nodes of trees T1 , . . . , Td . In this context, range searching means to determine all hyperedges connecting a given set of tree nodes. Buchsbaum et al. describe a data structure which supports, besides queries, adding and removing of edges; the tree nodes remain fixed. In this paper we present a new data structure, which additionally provides insertion and deletion of leaves of T1 , . . . , Td ; it combines the former approach with a novel technique of using search trees superimposed over ordered list maintenance structures. The extra cost for this dynamization is roughly a factor of log n /log log n). The trees being dynamic is especially important for maintaining hierarchical graph views, a problem that can be modeled as tree cross product. Such views evolve from a large base graph by the contraction of subgraphs defined recursively by an associated hierarchy. The graph view maintenance problem is to provide methods for refining and coarsening a view. In previous solutions only the edges of the underlying graph were dynamic; with the application of our data structure, the node set becomes dynamic as well.
The Euler Path to Static LevelAncestors
, 2007
"... Suppose a rooted tree T is given for preprocessing. The levelancestor problem is to answer quickly queries of the following form. Given a vertex v and an integer i> 0, find the ith vertex on the path from the root to v. Algorithms that achieve a linear time bound for preprocessing and a constant ti ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
Suppose a rooted tree T is given for preprocessing. The levelancestor problem is to answer quickly queries of the following form. Given a vertex v and an integer i> 0, find the ith vertex on the path from the root to v. Algorithms that achieve a linear time bound for preprocessing and a constant time bound for a query have been published by Dietz (1991), Alstrup and Holm (2000), and Bender and Farach (2002). The first two algorithms address dynamic versions of the problem; the last addresses the static version only and is the simplest. The purpose of this note is to expose another simple algorithm that lies under a complicated PRAM algorithm by Berkman and Vishkin (1990,1994). We further show that its simplicity allows for an easy extension of its functionality, adding queries for descendants and level successors as well as ancestors, extensions for which the former algorithm is less suitable. 1
Direct routing on trees (Extended Abstract)
 In Proceedings of the Ninth Annual ACMSIAM Symposium on Discrete Algorithms (SODA 98
, 1998
"... We consider offline permutation routing on trees. We are particularly interested in direct tree routing schedules where packets once started move directly towards their destination. The scheduling of start times ascertains that no two packets will use the same edge in the same direction in the same ..."
Abstract
 Add to MetaCart
We consider offline permutation routing on trees. We are particularly interested in direct tree routing schedules where packets once started move directly towards their destination. The scheduling of start times ascertains that no two packets will use the same edge in the same direction in the same time step. In O(n log n log log n) time and O(n log n) space, we construct a direct tree routing schedule guaranteed to complete the routing within the general optimum of n \Gamma 1 steps. In addition, our scheme guarantees that at most two packets arrive at the same node in the same time step. Furthermore, if the length of the route of a given packet is d and the maximum number of other routes intersecting the route in a single node is k then the packet arrives to its destination within d + k steps. 1 Introduction In this paper, we consider offline hotpotato permutation packet routing on trees. We are given a permutation ß of the nodes, and for each node v, we want to send a packet fr...
Practical Amortized Dynamic Indexing
"... The indexing problem is that of preprocessing a (very large) text T so that subsequent searches for patterns P can be accomplished in time O(jP j + tocc), where jP j is the pattern length and tocc is the number of occurrences of the pattern in the text. In the dynamic indexing problem the text ma ..."
Abstract
 Add to MetaCart
The indexing problem is that of preprocessing a (very large) text T so that subsequent searches for patterns P can be accomplished in time O(jP j + tocc), where jP j is the pattern length and tocc is the number of occurrences of the pattern in the text. In the dynamic indexing problem the text may be changed. We give a practical algorithm that preprocesses the text in time O(n log j\Sigmaj). Subsequently, the total amount of time necessary to do l searches interleaved with k text changes is O(km 2 + lm+ tocc), where m is the length of the maximum sized pattern. We also show how to improve the time to O(km log 2 n + lm + tocc). In the typical case where there are more queries than text changes and the pattern lengths are roughly equal, the time for each pattern query is O(m log 2 n + tocc). 1 Introduction The classical pattern matching problem is that of finding all occurrences of pattern P = p 1 p 2 \Delta \Delta \Delta p m in text T = t 1 t 2 \Delta \Delta \Delta t n ...