Results 1  10
of
14
Practical EntropyCompressed Rank/Select Dictionary
 PROCEEDINGS OF ALENEX’07, ACM
, 2007
"... Rank/Select dictionaries are data structures for an ordered set S ⊂ {0, 1,..., n − 1} to compute rank(x, S) (the number of elements in S which are no greater than x), and select(i, S) (the ith smallest element in S), which are the fundamental components of succinct data structures of strings, trees ..."
Abstract

Cited by 82 (2 self)
 Add to MetaCart
(Show Context)
Rank/Select dictionaries are data structures for an ordered set S ⊂ {0, 1,..., n − 1} to compute rank(x, S) (the number of elements in S which are no greater than x), and select(i, S) (the ith smallest element in S), which are the fundamental components of succinct data structures of strings, trees, graphs, etc. In those data structures, however, only asymptotic behavior has been considered and their performance for real data is not satisfactory. In this paper, we propose novel four Rank/Select dictionaries, esp, recrank, vcode and sdarray, each of which is small if the number of elements in S is small, and indeed close to nH0(S) (H0(S) ≤ 1 is the zeroth order empirical entropy of S) in practice, and its query time is superior to the previous ones. Experimental results reveal the characteristics of our data structures and also show that these data structures are superior to existing implementations in both size and query time.
Fullyfunctional succinct trees
 In Proc. 21st SODA
, 2010
"... We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and a large number of operations on the tree can be supported in constant time under the wordRAM model. However existing data s ..."
Abstract

Cited by 62 (22 self)
 Add to MetaCart
(Show Context)
We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and a large number of operations on the tree can be supported in constant time under the wordRAM model. However existing data structures are not satisfactory in both theory and practice because (1) the lowerorder term is Ω(nlog log n / log n), which cannot be neglected in practice, (2) the hidden constant is also large, (3) the data structures are complicated and difficult to implement, and (4) the techniques do not extend to dynamic trees supporting insertions and deletions of nodes. We propose a simple and flexible data structure, called the range minmax tree, that reduces the large number of relevant tree operations considered in the literature to a few primitives, which are carried out in constant time on sufficiently small trees. The result is then extended to trees of arbitrary size, achieving 2n + O(n/polylog(n)) bits of space. The redundancy is significantly lower than in any previous proposal, and the data structure is easily implemented. Furthermore, using the same framework, we derive the first fullyfunctional dynamic succinct trees. 1
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 50 (6 self)
 Add to MetaCart
(Show Context)
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
Ultrasuccinct representation of ordered trees
 In SODA ’07: Proceedings of the eighteenth annual ACMSIAM symposium on Discrete algorithms
, 2007
"... There exist two wellknown succinct representations of ordered trees: BP (balanced parenthesis) [Munro, Raman 2001] and DFUDS (depth first unary degree sequence) [Benoit et al. 2005]. Both have size 2n+o(n) bits for nnode trees, which asymptotically matches the informationtheoretic lower bound. Ma ..."
Abstract

Cited by 42 (4 self)
 Add to MetaCart
There exist two wellknown succinct representations of ordered trees: BP (balanced parenthesis) [Munro, Raman 2001] and DFUDS (depth first unary degree sequence) [Benoit et al. 2005]. Both have size 2n+o(n) bits for nnode trees, which asymptotically matches the informationtheoretic lower bound. Many fundamental operations on trees can be done in constant time on word RAM, for example finding the parent, the first child, the next sibling, the number of descendants, etc. However there has been no single representation supporting every existing operation in constant time; BP does not support ith child, while DFUDS does not support lca (lowest common ancestor). In this paper, we give the first succinct tree representation supporting every one of the fundamental operations previously proposed for BP or DFUDS along with some new operations in constant time. Moreover, its size surpasses the informationtheoretic lower bound and matches the entropy of the tree based on the distribution of node degrees. We call this an ultrasuccinct data structure. As a consequence, a tree in which every internal node has exactly two children can be represented in n + o(n) bits. We also show applications for ultrasuccinct compressed suffix trees and labeled trees. 1
Fullyfunctional static and dynamic succinct trees
, 2010
"... We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and various operations on the tree can be supported in constant time under the wordRAM model. However the data structures are c ..."
Abstract

Cited by 28 (15 self)
 Add to MetaCart
We propose new succinct representations of ordinal trees, which have been studied extensively. It is known that any nnode static tree can be represented in 2n + o(n) bits and various operations on the tree can be supported in constant time under the wordRAM model. However the data structures are complicated and difficult to dynamize. We propose a simple and flexible data structure, called the range minmax tree, that reduces the large number of relevant tree operations considered in the literature, to a few primitives that are carried out in constant time on sufficiently small trees. The result is extended to trees of arbitrary size, achieving 2n + O(n/polylog(n)) bits of space. The redundancy is significantly lower than any previous proposal. For the dynamic case, where insertion/deletion of nodes is allowed, the existing data structures support very limited operations. Our data structure builds on the range minmax tree to achieve 2n + O(n / log n) bits of space and O(log n) time for all the operations. We also propose an improved data structure using 2n+O(n loglog n / logn) bits and improving the time to O(log n / loglog n) for most operations.
Lineartime compression of boundedgenus graphs into informationtheoretically optimal number of bits
 In: 13th Symposium on Discrete Algorithms (SODA
, 2002
"... 1 I n t roduct ion This extended abstract summarizes a new result for the graph compression problem, addressing how to compress a graph G into a binary string Z with the requirement that Z can be decoded to recover G. Graph compression finds important applications in 3D model compression of Computer ..."
Abstract

Cited by 16 (1 self)
 Add to MetaCart
(Show Context)
1 I n t roduct ion This extended abstract summarizes a new result for the graph compression problem, addressing how to compress a graph G into a binary string Z with the requirement that Z can be decoded to recover G. Graph compression finds important applications in 3D model compression of Computer Graphics [12, 1720] and compact routing table of Computer Networks [7}. For brevity, let a ~rgraph stand for a graph with property n. The informationtheoretically optimal number of bits required to represent an nnode ngraph is [log 2 N~(n)], where N,~(n) is the number of distinct nnode *rgraphs. Although determining or approximating the close forms of N ~ (n) for nontrivial classes of n is challenging, we provide a lineartime methodology for graph compression schemes that are informationtheoretically optimal with respect to continuous uperadditive functions (abbreviated as optimal for the rest of the extended abstract). 1 Specifically, if 7r satisfies certain properties, then we can compress any nnode medge 1rgraph G into a binary string Z such that G and Z can be computed from each other in O(m + n) time, and that the bit count of Z is at most fl(n) + o(fl(n)) for any continuous uperadditive function fl(n) with log 2 N~(n) < fl(n) + o(fl(n)). Our methodology is applicable to general classes of graphs; this extended abstract focuses on graphs with sublinear genus. 2 For example, if the input nnode,rgraph G is equipped with an embedding on its genus surface, which is a reasonable assumption for graphs arising from 3D model compression, then our methodology is applicable to any 7r satisfying the following statements:
Engineering the LOUDS succinct tree representation
 In Proceedings of the 5th International Workshop on Experimental Algorithms. Lecture Notes in Computer Science 4007. SpringerVerlag, Cala Galdana, Menorca
, 2006
"... Abstract. Ordinal trees are arbitrary rooted trees where the children of each node are ordered. We consider succinct, or highly spaceefficient, representations of (static) ordinal trees with n nodes that use 2n + o(n) bits of space to represent ordinal trees. There are a number of such representati ..."
Abstract

Cited by 15 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Ordinal trees are arbitrary rooted trees where the children of each node are ordered. We consider succinct, or highly spaceefficient, representations of (static) ordinal trees with n nodes that use 2n + o(n) bits of space to represent ordinal trees. There are a number of such representations: each supports a different set of tree operations in O(1) time on the RAM model. In this paper we focus on the practical performance the fundamental LevelOrder Unary Degree Sequence (LOUDS) representation [Jacobson, Proc. 30th FOCS, 549–554, 1989]. Due to its conceptual simplicity, LOUDS would appear to be a representation with good practical performance. A tree can also be represented succinctly as a balanced parenthesis sequence [Munro and Raman, SIAM J. Comput. 31 (2001), 762–776; Jacobson, op. cit.; Geary et al. Proc. 15th CPM Symp., LNCS 3109, pp. 159–172, 2004]. In essence, the two representations are complementary, and have only the basic navigational operations in common (parent, firstchild, lastchild, prevsibling, nextsibling). Unfortunately, a naive implementation of LOUDS is not competitive with the parenthesis implementation of Geary et al. on the common set of operations. We propose variants of LOUDS, of which one, called LOUDS++, is competitive with the parenthesis representation. A motivation is the succinct representation of large static XML documents, and our tests involve traversing XML documents in various canonical orders. 1
Improved Compact Routing Tables for Planar Networks via Orderly Spanning Trees
 In: 8 th Annual International Computing & Combinatorics Conference (COCOON). Volume 2387 of LNCS
, 2002
"... We address the problem of designing compact routing tables for an unlabeled connected nnode planar network G. For each node r of G, the designer is given a routing spanning tree Tr of G rooted at r, which speci es the routes for sending packets from r to the rest of G. ..."
Abstract

Cited by 11 (3 self)
 Add to MetaCart
We address the problem of designing compact routing tables for an unlabeled connected nnode planar network G. For each node r of G, the designer is given a routing spanning tree Tr of G rooted at r, which speci es the routes for sending packets from r to the rest of G.
Succinct Geometric Indexes Supporting Point Location Queries
"... We propose to design data structures called succinct geometric indexes of negligible space (more precisely, o(n) bits) that support geometric queries in optimal time, by taking advantage of the n points in the data set permuted and stored elsewhere as a sequence. Our first and main result is a succi ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
(Show Context)
We propose to design data structures called succinct geometric indexes of negligible space (more precisely, o(n) bits) that support geometric queries in optimal time, by taking advantage of the n points in the data set permuted and stored elsewhere as a sequence. Our first and main result is a succinct geometric index that can answer point location queries, a fundamental problem in computational geometry, on planar triangulations in O(lg n) time1. We also design three variants of this index. The first supports point location using lg n +2 √ lg n + O(lg 1/4 n) pointline comparisons. The second supports point location in o(lg n) time when the coordinates are integers bounded by U. The last variant can answer point location queries in O(H +1) expected time, where H is the entropy of the query distribution. These results match the query efficiency of previous point location structures that occupy O(n) words or O(n lg n) bits, while saving drastic amounts of space. We generalize our succinct geometric index to planar subdivisions, and design indexes for other types of queries. Finally, we apply our techniques to design the first implicit data structures that support point location in O(lg² n) time.
Balanced Parentheses Strike Back
"... An ordinal tree is an arbitrary rooted tree where the children of each node are ordered. Succinct representations for ordinal trees with efficient query support have been extensively studied. The best previously known result is due to Geary, Raman, and Raman [SODA 2004, pages 1–10]. The number of bi ..."
Abstract

Cited by 9 (1 self)
 Add to MetaCart
(Show Context)
An ordinal tree is an arbitrary rooted tree where the children of each node are ordered. Succinct representations for ordinal trees with efficient query support have been extensively studied. The best previously known result is due to Geary, Raman, and Raman [SODA 2004, pages 1–10]. The number of bits required by their representation for an nnode ordinal tree T is 2n + o(n), whose firstorder term is informationtheoretically optimal. Their representation supports a large set of O(1)time queries on T. Based upon a balanced string of 2n parentheses, we give an improved 2n + o(n)bit representation for T. Our improvement is two fold: Firstly, the set of O(1)time queries supported by our representation is a proper superset of that supported by the representation of Geary, Raman, and Raman. Secondly, it is also much easier for our representation to support new queries by simply adding new auxiliary strings.