Fully-Functional Succinct Trees
Kunihiko Sadakane∗ Gonzalo Navarro†
Abstract case this number of bits is necessary to distinguish any We propose new succinct representations of ordinal trees, two objects. The size of the corresponding succinct data which have been studied extensively. It is known that any structure is typically (1 + o(1)) log L bits. n-node static tree can be represented in 2n + o(n) bits and a large number of operations on the tree can be sup- In this paper we are interested in ordinal trees, ported in constant time under the word-RAM model. How- in which the children of a node are ordered. The ever existing data structures are not satisfactory in both information-theoretic lower bound to store an ordinal theory and practice because (1) the lower-order term is − Ω(n log log n/ log n), which cannot be neglected in practice, tree with n nodes is 2n Θ(log n) bits because there 2n−1 n 3 (2) the hidden constant is also large, (3) the data structures − 2 2 exist n−1 /(2n 1) = 2 /Θ(n ) such trees [26]. are complicated and difficult to implement, and (4) the tech- We assume that the computation model is the word niques do not extend to dynamic trees supporting insertions and deletions of nodes. RAM with word length Θ(log n) in which arithmetic We propose a simple and flexible data structure, called and logical operations on Θ(log n)-bit integers and the range min-max tree, that reduces the large number Θ(log n)-bit memory accesses can be done in constant of relevant tree operations considered in the literature to a few primitives, which are carried out in constant time time. Under this model, there exist many succinct on sufficiently small trees. The result is then extended representations of ordinal trees achieving 2n + o(n) bits n O n/ n to trees of arbitrary size, achieving 2 + ( polylog( )) of space. bits of space. The redundancy is significantly lower than in any previous proposal, and the data structure is easily Basically there exist three types of such tree implemented. Furthermore, using the same framework, we representations: the balanced parentheses sequence derive the first fully-functional dynamic succinct trees. (BP) [20, 26], the level-order unary degree sequence (LOUDS) [20, 8], and the depth-first unary degree se- 1 Introduction quence (DFUDS) [5, 21]. An example of them is shown Trees are one of the most fundamental data structures, in Figure 1. LOUDS is a simple representation, but it needless to say. A classical representation of a tree with lacks many basic operations, such as giving the subtree n nodes uses O(n) pointers or words. Because each size of a tree node. Both BP and DFUDS build on a pointer must distinguish all the nodes, it requires log n sequence of balanced parentheses, the former using the bits1 in the worst case. Therefore the tree occupies intuitive depth-first-search representation and the lat- Θ(n log n) bits, which causes a space problem for ma- ter using a more sophisticated one. The advantage of nipulating large trees. Much research has been devoted DFUDS, when it was created, was that it supported a to reducing the space to represent static trees [20, 26, more complete set of operations in constant time, most 27, 29, 16, 17, 5, 10, 7, 8, 22, 19, 2, 18, 35, 21, 9] and notably going to the i-th child of a node. Later, this dynamic trees [28, 34, 6, 1], achieving so-called succinct was also achieved using BP representation, yet requir- data structures for trees. ing complicated additional data structures with non- A succinct data structure stores objects using space negligible lower-order terms in their space usage [22]. close to the information-theoretic lower bound, while si- Another type of succinct ordinal trees, based on tree multaneously supporting a number of primitive opera- covering [17, 19, 9], has also achieved constant-time sup- tions on the objects in constant time. The information- port of known operations, yet inheriting the problem of theoretic lower bound for storing an object from a uni- nonnegligible lower-order terms in size. verse with cardinality L is log L bits because in the worst 1.1 Our contributions ∗ National Institute of Informatics (NII), 2-1-2 Hitotsubashi, We focus on the BP representation, and achieve con- Chiyoda-ku, Tokyo 101-8430, Japan. [email protected]. Work sup- stant time for a large set of operations2. What dis- ported in part by the Grant-in-Aid of the Ministry of Education, Science, Sports and Culture of Japan. tinguishes our proposal is its simplicity, which allows †Department of Computer Science, University of Chile. [email protected]. Funded in part by Millennium Insti- tute for Cell Dynamics and Biotechnology (ICDB), Grant ICM 2Moreover, as we manipulate a sequence of balanced paren- P05-001-F, Mideplan, Chile. theses, our data structure can be used to implement a DFUDS 1The base of logarithm is 2 throughout this paper. representation as well.
134 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. 1 Theorem 1.2. On a Θ(log n)-bit word RAM, all op- erations on a dynamic ordinal tree with n nodes can Ordinal tree be carried out within the worst-case complexities given 2 6 in Table 1, using a data structure that requires 2n + O(n log log n/ log n) bits. Alternatively, they can be car- ried out in O(log n) time using 2n + O(n/ log n) bits of 3 4 5 7 8 space. There exist no previous dynamic data structures 1 supporting all the operations in Table 1. The data 2 6 structure of Raman and Rao [34] supports, for binary 3 4 5 7 8 trees, parent , left and right child, and subtree-size of BP ((()()())(()())) the current node in the course of traversing the tree in constant time, and updates in O((log log n)1+ ) time. DFUDS ((()((())))(())) Note that this data structure assumes that all traver- 1 2 3 4 5 6 7 8 sals start from the root. Chan et al. [6] gave a dynamic data structure using O(n) bits and supporting find- LOUDS 110111011000000 close and enclose, and updates, in O(log n/ log log n) 1 2 6 3 4 5 7 8 time. They show this time is indeed optimal, by reduc- tion from dynamic rank/select on bitmaps and given the lower bound of Fredman and Saks [14]. They also Figure 1: Succinct representations of trees. gave another data structure using O(n) bits and sup- porting findclose, enclose, lca, leaf-rank, leaf-select, and O easy implementation and derivation of dynamic vari- updates, in (log n) time. ants with the same functionality; and its economy in The simplicity and space-efficiency of our data the sublinear-space structures, which results in a con- structures stem from the fact that any query operation siderably smaller lower-order term in the space usage. in Table 1 is reduced to a few basic operations on a For the static case, we obtain the following result. bit vector, which can be efficiently solved by a range min-max tree. This approach is different from previous Theorem 1.1. For any ordinal tree with n nodes, all studies in which each operation needs distinct auxiliary operations in Table 1 except insert and delete are carried data structures. Therefore their total space is the out in constant time O(c2) with a data structure using summation over all the data structures, which enlarges c 2n + O(n/ log n) bits of space on a Θ(log n)-bit word the hidden constant in the lower-order term of the size. RAM, for any constant c>0. The data structure can For example, the first succinct representation of BP [26] be constructed from the balanced parentheses sequence supported only findclose, findopen, and enclose (and of the tree, in O(n) time using O(n) bits. other easy operations) and each operation used different data structures. Later, many further operations such Our data structure improves upon the lower-order as lmost-leaf [27], lca [35], degree [7], child and child- term in the space complexity of previous representa- rank [22], and level-ancestor [29], were added to this tions. For example, formerly the extra data structure√ representation by using other types of data structures for level-ancestor has required O(n log log n/ log n) for each. There exists another elegant data structure bits [29], or O(n(log log n)2/ log n) bits3 [21], and for BP supporting findclose, findopen, and enclose [16]. that for child has required O(n/(log log n)2) bits [22]. This reduces the size of the data structure for these The previous representation with maximum function- basic operations, but still has to add extra auxiliary ality [9] supports all the operations in Table 1, ex- data structures for other operations. cept insert and delete, in constant time using 2n + Former static approaches use two-level data struc- O(n log log log n/ log log n)-bit space. Ours requires tures to reduce the size, which causes difficulties in dy- c O(n/ log n) bits for all the operations. namic case. Our approach using the range min-max For the dynamic case, the following theorem sum- tree, instead, is easily translated to the dynamic setting, marizes our results. resulting in simple and efficient dynamic data structures that support all of the operations in Table 1.
3This data structure is for DFUDS, but the same technique 1.2 Organization of the paper can be also applied to BP. In Section 2 we review basic data structures used in
135 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Table 1: Operations supported by our data structure. The time complexities are for the dynamic case; in the static case all operations are performed in constant time. The first group is composed of basic operations, used to implement the others, yet they could have other uses. operation description time complexity inspect(i) P [i] O(log n/ log log n) findclose(i)/findopen(i) position of parenthesis matching P [i] O(log n/ log log n) enclose(i) position of tightest open parent. enclosing node i O(log n/ log log n) rank((i)/rank)(i) number of open/close parentheses in P [1,i] O(log n/ log log n) select((i)/select)(i) position of i-th open/close parenthesis O(log n/ log log n) rmqi(i, j)/RMQi(i, j) position of min/max excess value in range [i, j] O(log n/ log log n) pre-rank(i)/post-rank(i) preorder/postorder rank of node i O(log n/ log log n) pre-select(i)/post-select(i) the node with preorder/postorder i O(log n/ log log n) isleaf(i) whether P [i] is a leaf O(log n/ log log n) isancestor(i, j) whether i is an ancestor of j O(log n/ log log n) depth(i) depth of node i O(log n/ log log n) parent(i) parent of node i O(log n/ log log n) first-child(i)/last-child(i) first/last child of node i O(log n/ log log n) next-sibling(i) /prev-sibling(i) next/previous sibling of node i O(log n/ log log n) subtree-size(i) number of nodes in the subtree of node i O(log n/ log log n) level-ancestor(i, d) ancestor j of i such that depth(j)=depth(i) − d O(log n)or O(d + log n/ log log n) level-next(i)/level-prev(i) next/previous node of i in BFS order O(log n/ log log n) level-lmost(d)/level-rmost(d) leftmost/rightmost node with depth d O(log n)or O(d + log n/ log log n) lca(i, j) the lowest common ancestor of two nodes i, j O(log n/ log log n) deepest-node(i) the (first) deepest node in the subtree of i O(log n/ log log n) degree(i) number of children of node i O(log n/ log log n) child(i, q) q-th child of node i O(log n/ log log n) child-rank(i) number of siblings to the left of node i O(log n/ log log n) in-rank(i) inorder of node i O(log n/ log log n) in-select(i) node with inorder i O(log n/ log log n) leaf-rank(i) number of leaves to the left of leaf i O(log n/ log log n) leaf-select(i) i-th leaf O(log n/ log log n) lmost-leaf(i)/rmost-leaf(i) leftmost/rightmost leaf of node i O(log n/ log log n) insert(i, j) insert node given by matching parent. at i and j O(log n/ log log n) delete(i) delete node i O(log n/ log log n)
this paper. In Section 3 we describe the main ideas for selectc(S, rankc(S, i)) ≤ i. our new data structures for ordinal trees. Sections 4 There exist many succinct data structures for and 5 describe the static construction. In Sections 6 rank/select [20, 25, 33]. A basic one uses n + o(n) and 7 we give two data structures for dynamic ordinal bits and supports rank/select in constant time on the trees. In Section 8 we conclude and give future work word RAM with word length O(log n). The space can directions. be reduced if the number of 1’s is small. For a string with m 1’s, there exists a data structure for constant- n 2 Preliminaries time rank/select using log m + O(n log log n/ log n)= n m log m + O(m + n log log n/ log n) bits [33]. Recently Here we describe the balanced parentheses sequence and n basic data structures used in this paper. [30] the extra space has been reduced to m log m + t O(ntt/ log n + n3/4) bits, performing rank and select 2.1 Succinct data structures for rank/select in O(t) time. This can be built in linear worst-case Consider a bit string S[0,n − 1] of length n.Wetime4. define rank and select for S as follows: rankc(S, i) is the number of occurrences c ∈{0, 1} in S[0,i], 4They use a predecessor structure by Pˇatra¸scu and Thorup and selectc(S, i) is the position of the i-th occurrence −lg n [31], more precisely their result achieving time “lg a ”, which of c in S. Note that rankc(S, selectc(S, i)) = i and is a simple modification of van Emde Boas’ data structure.
136 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. A crucial technique for succinct data structures is pre-select(i)=select1(P, i) table lookup. For small-size problems we construct a post-rank(i)=rank0(P, i) table which stores answers for all possible sequences post-select(i)=select (P, i) and queries. For example, for rank and select,we 0 first-child(i)=i + 1 (if i is not a leaf) use a table storing all answers for all 0,1 patterns√ of 1 n 1 2 log − length 2 log n. Because there exist only 2 = n last-child(i)=findopen(P, findclose(P, i) 1) different patterns, we can store all answers in a universal (if i is not a leaf) table (i.e., not depending on the bit sequence) that uses √ next-sibling(i)=findclose(i)+1 n · polylog(n)=o(n/polylog(n)) bits, which can be accessed in constant time on a word RAM with word (if P [findclose(i)+1]=0, length Θ(log n). then i is the last sibling) prev-sibling(i)=findopen(i − 1) (if P [i − 1] = 1 2.2 Succinct tree representations then i is the first sibling) We will focus on the BP representation of trees. A − rooted ordered tree T , or ordinal tree, with n nodes subtree-size(i)=(findclose(i) i +1)/2 is represented by a string P [0, 2n − 1] of balanced parentheses of length 2n. A node v ∈ T is represented Hence the above operations will not be considered by a pair of matching parentheses ( ...) and all subtrees further in the paper. Let us now focus on a small set rooted at the node are encoded in order between the of primitives needed to implement most of the other · { } matching parentheses (see Figure 1 for an example). operations. For any function g( )on 0, 1 , we define Moreover, node v is identified with the position i of the the following. open parenthesis P [i] representing the node. Definition 1. − In the static setting, the tree does not change. In For a 0,1 vector P [0,n 1] and a · { } the dynamic setting, we consider insertion and deletion function g( ) on 0, 1 , of internal nodes or leaves. More precisely, we accept j inserting a new pair of matching parentheses at any legal sum(P, g, i, j) def= g(P [k]) position of P , as well as deleting any existing pair of k=i matching parentheses. fwd-search(P, g, i, d) def= min{j | sum(P, g, i, j)=d} j≥i 3 Fundamental concepts bwd-search(P, g, i, d) def= max{j | sum(P, g, j, i)=d} In this section we give the basic ideas of our ordinal tree j≤i representation. In the next sections we build on these rmq(P, g, i, j) def= min {sum(P, g, i, k)} to define our static and dynamic representations. i≤k≤j 5 We represent a possibly non-balanced parentheses def − ∈{ } rmqi(P, g, i, j) = argmin{sum(P, g, i, k)} sequence by a 0,1 vector P [0,n 1] (P [i] 0, 1 ). Each i≤k≤j opening/closing parenthesis is encoded by ( = 1, ) = 0. RMQ(P, g, i, j) def= max {sum(P, g, i, k)} First, we remind the reader that several operations i≤k≤j of Table 1 either are trivial in a BP representation, or def are easily solved using enclose, findclose, findopen, rank, RMQi(P, g, i, j) = argmax{sum(P, g, i, k)} i≤k≤j and select [26]. These are: The following function is particularly important. inspect(i)=rank1(P, i) − rank1(P, i − 1) (if accessing P [i] is problematic) Definition 2. Let π be the function such that π(1) = isleaf(i)=[inspect(i +1)=0] 1,π(0) = −1. Given P [0,n− 1], we define the excess − isancestor(i, j)=i ≤ j and array E[0,n 1] of P as an integer array such that E[i]=sum(P, π, 0,i). findclose(P, j) ≤ findclose(P, i) − depth(i)=rank1(P, i) rank0(P, i) Note that E[i] stores the difference between the parent(i)=enclose(P, i) number of opening and closing parentheses in P [0,i]. When P [i] is an opening parenthesis, E[i]=depth(i)is pre-rank(i)=rank1(P, i) the depth of the corresponding node, and is the depth 5Later we will use these constructions to represent arbitrary minus 1 for closing parentheses. We will use E as chunks of a balanced sequence. a conceptual device in our discussions, it will not be
137 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. stored. Note that, given the form of π, it holds that level-prev(i)=findopen(bwd-search(P, π, i, 0)) | − | E[i +1] E[i] = 1 for all i. level-lmost(d)=fwd-search(P, π, 0,d) The above operations are sufficient to implement level-rmost(d)=findopen(bwd-search(P, π, n−1, −d)) the basic navigation on parentheses, as the next lemma shows. Note that the equation for findclose is well To compute degree, child, and child-rank, the fol- known, and the one for level-ancestor has appeared as lowing lemma is important. well [29], but we give proofs for completeness. Lemma 3.2. The number of children of node i is equal Lemma 3.1. Let P be a BP sequence encoded by {0, 1}. to the number of occurrences of the minimum value in Then findclose, findopen, enclose, and level-ancestor E[i +1, findclose(i) − 1]. can be expressed as follows. Proof. Let d = E[i]=depth(i) and j = findclose(i). findclose(i)=fwd-search(P, π, i, 0) Then E[j]=d − 1 and all excess values in E[i +1,j− 1] findopen(i)=bwd-search(P, π, i, 0) are ≥ d. Therefore, as |E[r +1]− E[r]| = 1 for all r, enclose(i)=bwd-search(P, π, i, 2) the minimum value in E[i +1,j − 1] is d. Moreover, for the range [ik,jk] corresponding to the k-th child of level-ancestor(i, d)=bwd-search(P, π, i, d +1) i, E[ik]=d +1, E[jk]=d, and all the values between Proof. For findclose, let j>ibe the position of the them are >d. Therefore the number of occurrences of − closing parenthesis matching the opening parenthesis at d, which is the minimum value in E[i+1,j 1], is equal P [i]. Then j is the smallest index >isuch that E[j]= to the number of children of i. E[i]−1=E[i−1] (because of the node depths). Since by definition E[k]=E[i − 1] + sum(P, π, i, k) for any k>i, We also show that the above functions unify the j is the smallest index >isuch that sum(P, π, i, j)=0. algorithms for computing rank/select on 0,1 vectors and This is, by definition, fwd-search(P, π, i, 0). those for balanced parenthesis sequences. Namely, let For findopen, let j 138 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. n c a 2 s · log(2w +1) = O(nc log w/w) bits each. The 0/4 depth of the tree is logk(n/s) = O(c). The following fact is well known; we reprove it for b f j completeness. 1/4 1/3 0/2 Lemma 4.1. Any range [i..j] ⊆ [0..n − 1] in TmM can c d e g h i k l be represented by a disjoint union of O(ck) subranges m/M 1/2 2/4 3/4 2/3 1/3 2/3 1/2 0/0 where the leftmost and rightmost ones may be subranges E 1212343432321232321210 of leaves of TmM , and the others correspond to whole tree nodes. P (()((()())())(()())()) Proof. Let a be the smallest value such that i ≤ ra and b be the largest such that j ≥ b. Then Figure 2: An example of the range min-max tree using the range [i..j] is covered by the partition [i..j]= function π, and showing the m/M values. [i..ra][a+1..ra+1] ...[b..j] (we can discard the special case a = b, as in this case we have already one leaf in its child nodes. Thus, the root node stores e = covering [i..j]). Then [i..ra] and [b..j] are the leftmost sum(P, g, 0,n− 1), m = rmq(P, g, 0,n− 1) and M = and rightmost leaf subranges alluded in the lemma; all RMQ(P, g, 0,n− 1). the others are whole tree nodes. It remains to show that we can reexpress this Example 1. An example of range min-max tree is partition using O(ck) tree nodes. If all the k children shown in Figure 2. Here we use g = π, and thus the of a node are in the range, we replace the k children nodes store the minimum/maximum values of array E by the parent node, and continue recursively level by in the corresponding interval. level. Note that if two parent nodes are created in a given level, then all the other intermediate nodes of the same level must be created as well, because the 4 A simple data structure for moderate-size original/created nodes form a range at any level. At trees the end, there cannot be more than 2k − 2 nodes at any Building on the previous ideas, we give a simple data level, because otherwise k of them would share a single structure to compute fwd-search, bwd-search, and sum parent and would have been replaced. As there are c in constant time for arrays of moderate size. Then we levels, the obtained set of nodes covering [i..j] is of size will consider further operations. O(ck). Let g(·) be a function on {0, 1} taking values in { − } ± 1, 0, 1 . We call such a function 1 function. Note Example 2. In Figure 2 (where s = k =3), the range that there exist only six such functions where g(0) = [3..18] is covered by [3..5], [6..8], [9..17], [18..18]. They − − − g(1), which are indeed φ, φ, ψ, ψ, π, π. correspond to nodes d, e, f, and a part of leaf k, Let w be the bit length of the machine word in the respectively. RAM model, and c ≥ 1 any constant. We have a (not necessarily balanced) parentheses vector P [0,n− 1], of Computing fwd-search(P, g, i, d) is done as follows moderate size n ≤ N = wc. Assume we wish to solve (bwd-search is symmetric). First we check if the block the operations for an arbitrary ±1 function g(·), and let of i,[k,rk] for k = i/s , contains fwd-search(P, g, i, d) G[i] denote sum(P, g, 0,i), analogously to E[i] for g = π. with table lookup using vector P , by precomputing√ a s 2 w 2 Our data structure is a range min-max tree TmM for simple universal table of 2 ·2s ·log s = O( 2 w log w) · 1 vector P and function g( ). Let s = 2 w. We imaginarily bits. If so, we are done. Else, we compute the global divide vector P into n/s blocks of length s. These target value we seek, d = G[i − 1] + d = e[k] − form the partition alluded in Definition 3: i = s·(i−1). sum(P, g, i, rk)+d (again, the sum inside the block is Thus the values m[i] and M[i] correspond to minima done in constant time using table lookup). Now we and maxima of G within each block, and e[i]=G[ri]. divide the range [rk +1,n− 1] into subranges I1,I2,... Furthermore, the tree will be k-ary and complete, represented by range min-max tree nodes u1,u2,... as for k =Θ(w/ log w). Because it is complete, the tree can in Lemma 4.1. Then, for each Ij , we check if the target be represented just by three integer arrays e [0, O(n/s)], value d is between m[uj] and M[uj], the minimum and m [0, O(n/s)], and M [0, O(n/s)], like a heap. maximum values of subrange Ij . Let Ik be the first j c c Because −w ≤ e [i],m[i],M [i] ≤ w for any i, such that m[uj] ≤ d ≤ M[uj], then fwd-search(P, g, i, d) arrays e , m and M occupy at most (i.e., for k =2) lies within Ik.IfIk corresponds to an internal tree node, 139 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. we iteratively find the leftmost child of the node whose table with all the possible sequences of k/c m[·] values range contains d, until we reach a leaf. Finally, we find and all possible −wc ≤ d ≤ wc values, and for each such the target in the block corresponding to the leaf by table sequence and d we store the first j in the sequence such lookup, using P again. that m[j] ≤ d (or we store a mark telling that there is no such node in the sequence). Thus the table has Example 3. In Figure 2, where G = E and g = π, (2wc +1)(k/c)+1 entries, and log(1 + k/c) bits per entry. computing findclose(3) = fwd-search(P, π, 3, 0)=12can By choosing the constant of k =Θ(w/√log w) so that be done as follows. Note this is equivalent to finding the k ≤ cw −c, the total space is O( 2w log w) (and − 2 log(2w+1) first j>3 such that E[i]=E[3 1]+0=1. First the arguments for the table fit in a machine word). With examine the node 3/s =1(labeled d in the figure). the table, each search for the first node in a sequence of We see that the target 1 does not exist within d after siblings can be done by chunks of k/c nodes, which takes position 3. Next we examine node e. Since m[e]=3and O(k/(k/c)) = O(c) rather than O(k) time, and hence M[e]=4, e does not contain the answer either. Next we the overall time is O(c2) rather than O(ck). Note that examine the node f. Because m[f]=1and M[f]=3, k/c values to input to the table are stored in contiguous the answer must exist in its subtree. Therefore we scan memory, as we store the m[·] values in heap order. Thus the children of f from left to right, and find the leftmost we can access any k/c consecutive children values in · ≤ one with m[ ] 1, which is node h. Because node h is constant time. We use an analogous table for M[·]. already a leaf, we scan the segment corresponding to it, Finally, the process to solve sum(P, g, i, j)inO(c2) and find the answer 12. time is simple. We descend in the tree up to the leaf [k,rk] containing j. In the process we eas- The sequence of subranges arising in this search ily obtain sum(P, g, 0,k − 1), and compute the rest, corresponds to a leaf-to-leaf path in the range min- sum(P, g, k,j), in constant time using a universal table max tree, and it contains O(ck) ranges according to we have already introduced. We repeat the process for Lemma 4.1. We show now how to carry out this search sum(P, g, 0,i− 1) and then subtract both results. in time O(c2) rather than O(ck). We have proved the following lemma. According to Lemma 4.1, the O(ck) nodes can be O partitioned into (c) sequences of sibling nodes. We Lemma 4.3. In the RAM model with w-bit word size, will manage to carry out the search within each such for any constant c ≥ 1 and a 0,1 vector P of length O sequence in (c) time. Assume we have to find the n 140 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. of the range min-max tree. The minimum values of process chunks of k/c children at once, that is, the one such leaf subranges are found by table lookups√ using P , used for rmqi plus another telling the number of times w by precomputing a universal table of O( 2 w2 log w) the minimum√ appears in the sequence. This table also w bits. The minimum value of a subsequence μ ,...,μr requires O( 2 w) bits. which shares the same parent in the range min-max Operation child-rank(i) can be computed similarly, tree can be also found by table lookups. There are at by counting the number of minima in E[parent(i),i−1]. most k such values, and for consecutive k/c values we Operation child(i, q) follows the same idea of degree(i), use a universal table to find their minimum, and re- except that, in the node where the sum of n[·] exceeds peat√ this c times, as before.√ The size of the table is q, we must descend until the range min-max leaf that O( 2w(k/c) log(k/c)) = O( 2ww) bits (the k/c factor contains the opening parenthesis of the q-th child. This is to account for queries that span less than k/c blocks, search is also guided by the n[·] values of each node, and so we can compute the minimum up to any value in the is done also√ in O(c2) time by using another universal sequence). table of O( 2w log w) bits (that tells us where the n[·] Let μ be the minimum value we find in exceed some threshold in a sequence of k/c values). μ1,μ2,...,μm. If there is a tie, we choose the leftmost For operations leaf-rank, leaf-select, lmost-leaf and one. If μ corresponds to an internal node of the range rmost-leaf, we define a bit-vector P1[0,n − 1] such min-max tree, we traverse the tree from the node to a that P1[i]=1 ⇐⇒ P [i]=1∧ P [i +1]=0. leaf having the leftmost minimum value. At each step, Then leaf-rank(i)=rank1(P1,i) and leaf-select(i)= we find the leftmost child of the current node having select1(P1,i) hold. The other operations are computed the minimum, in O(c) time using our precomputed ta- by lmost-leaf(i)=select1(P1, rank1(P1,i− 1) + 1) and ble. We repeat the process from the resulting child, until rmost-leaf(i)=select1(P1, rank1(P1, findclose(i))). reaching a leaf. Finally, we find the index of the mini- We recall the definition of inorder of nodes, which mum value in the leaf, in constant time by a lookup on is essential for compressed suffix trees. our other universal table. The overall time complexity is O(c2). Definition 4. ([35]) The inorder rank of an internal node v is defined as the number of visited internal nodes, including v, in the left-to-right depth-first traversal, 4.2 Other operations when v is visited from a child of it and another child The previous development on fwd-search, bwd-search, of it will be visited next. rmqi, and RMQi, has been general, for any g(·). Applied to g = π, they solve a large number of operations, as Note that an internal node with q children has q −1 shown in Section 3. For the remaining ones we focus inorders, so leaves and unary nodes have no inorder. We directly on the case g = π. define in-rank(i) as the smallest inorder value of internal It is obvious how to compute degree(i), child(i, q) node i. and child-rank(i) in time proportional to the degree of To compute in-rank and in-select, we use another the node. To compute them in constant time, we use bit-vector P2[0,n− 1] such that P2[i]=1 ⇐⇒ P [i]= Lemma 3.2, that is, the number of children of node i is 0∧P [i+1] = 1. The following lemma gives an algorithm equal to the number of minimum values in the excess to compute the inorder of an internal node. array for i. We add another array n[·] to the data structure. In the range min-max tree, each node stores Lemma 4.5. ([35]) Let i be an internal node, and let the minimum value of its subrange. In addition to this, j = in-rank(i),soi = in-select(j). Then we also store in n[·] the number of the minimum values of the subrange of each node in the tree. in-rank(i)=rank1(P2, findclose(P, i + 1)) Now we can compute degree(i) in constant time. in-select(j)=enclose(P, select1(P2,j)+1) Let d = depth(i) and j = findclose(i). We partition the range E[i+1,j−1] into O(ck) subranges, each of which Note that in-select(j) will return the same node i corresponds to a node of the range min-max tree. Then for any its degree(i) − 1 inorder values. for each subrange whose minimum value is d, we sum up the number of occurrences of the minimum value (n [·]). Note that we need not store P1 and P2 explicitly; The number of occurrences of the minimum value in leaf they can be computed from P when needed. We only subranges can be computed√ by table lookup on P , with need the extra data structures for constant-time rank a universal table using O( 2ww2 log w) bits. The time and select, which can be reduced to the corresponding 2 complexity is O(c ) if we use universal tables that let us sum and fwd-search operations on the virtual P1 and P2 vectors. 141 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. 4.3 Reducing extra space tree [15] that is used internally on O(w) values. It could Apart from vector P [0,n− 1], we need to store vec- be reduced to w time for any constant >0 and tors e, m, M , and n. In addition, to imple- navigation time O(1/), but we prefer to set c>3/2 ment rank and select using sum and fwd-search,we to make it irrelevant. would need to store vectors eφ, eψ, mφ, mψ, Mφ, These parameters still allow us to represent our and Mψ which maintain the corresponding values for range min-max trees while yielding the complexities functions φ and ψ. However, note that sum(P, φ, 0,i) we had found, as k =Θ(w/ log w) and N ≤ wc. and sum(P, ψ, 0,i) are nondecreasing, thus the mini- Our accesses to the range min-max tree are either (i) mum/maximum within the block is just the value of partitioning intervals [i, j]intoO(ck) subranges, which the sum at the beginning/end of the block. Moreover, are easily identified by navigating from the root in O(c) as sum(P, π, 0,i)=sum(P, φ, 0,i) − sum(P, ψ, 0,i) and time (as the k children are obtained together in constant sum(P, φ, 0,i)+sum(P, ψ, 0,i)=i, it turns out that time); or (ii) navigating from the root while looking both eφ[i]=(ri + e[i])/2 and eψ[i]=(ri − e[i])/2 are re- for some leaf based on the intermediate m, M, n,ore dundant; analogous formulas hold for M and m and for values. internal nodes. Moreover, any sequence of k/c consecu- Thus we retain all of our time complexities.√ The tive such values can be obtained, via table lookup, from space, instead, is reduced to N +2+O( 2w), where the sequence of k/c consecutive values of e[·], because the latter part comes from universal tables (ours also the ri values increase regularly at any node. Hence we shrink due to the reduced k and s). Note that our vector do not store any extra information to support φ and ψ. P must be exactly of length N; padding is necessary If we store vectors e, m, M , and n naively, we otherwise. Both the padding and the universal tables require O(nc log(w)/w) bits of extra space on top of the will lose relevance for larger trees, as seen in the next n bits for P . section. The space can be largely reduced by using a recent The next theorem summarizes our results in this w c technique by Pˇatra¸scu[30]. They define an aB-tree over section. We are able of handling trees of Θ(( c log w ) ) an array A[0,n− 1], for n a power of B, as a complete nodes, for any c>3/2. tree of arity B, storing B consecutive elements of A in each leaf. Additionally, a value ϕ ∈ Φ is stored at each Theorem 4.1. On a w-bit word RAM, for any con- node. This must be a function of the corresponding stant c>3/2, we can represent a sequence P of N = Bc w elements of A for the leaves, and a function of the parentheses, with sufficiently small B =Θ(c log w ), com- ϕ values of the children, and of the subtree size, for puting all operations of Table 1 in O(c2) time, with a internal nodes. The construction is able to decode the data structure depending on P that uses N +2 bits, B values of ϕ for the children of any node in constant and universal lookup√ tables (i.e., not depending on w time, and to decode the B values of A for the leaves in P ) that√ use O( 2 ) bits. The preprocessing time is constant time, if they can be packed in a machine word. O(N + 2wpoly(w)) (the latter being needed only once In our case, A = P is the vector, B = for universal tables) and the working space is O(N) bits. k = s is our arity, and our trees will be of size c c N = B , which is slightly smaller than the w In case we need to solve the operations that build we have been assuming. Our values are tuples on P1 and P2, we need to represent their corresponding c c c c c c c ϕ ∈−B , −B , 0, −B ...B ,B ,B ,B encoding φ functions (as ψ is redundant). This can still be the m, M, n, and e values at the nodes, respectively. done with Lemma 4.6 using Φ = (2B +1)6c and (B + We give next their result, adapted to our case. ≤ w 1) log(2B +1) 12c . Theorem 4.1 applies verbatim. Lemma 4.6. (adapted from Thm. 8 in [30]) 5 A data structure for large trees Let Φ=(2B +1)4c, and B be such that ≤ w w In practice, one can use the solution of the previous (B + 1) log(2B +1) 8c (thus B =Θ(c log w )). k log n c section for trees of any size, achieving O( w logk n)= An aB-tree of size N = B with values in Φ can be n O( log )=O(log n) time (using k = w/ log n) stored√ using N +2 bits, plus universal lookup tables of log w−log log n O( 2w) bits. It can obtain the m, M, n or e values of for all operations with an extremely simple and elegant data structure (especially if we choose to store arrays the children of any node, and descend to any of those children, in constant time. The√ structure can be built m , etc. in simple form). In this section we show how in O(N + w3/2) time, plus O( 2wpoly(w)) for the to achieve constant time on trees of arbitrary size. universal tables. For simplicity, let us assume in this section that we handle trees of size wc in Section 4. We comment at the The “+w3/2” construction time comes from a fusion end the difference with the actual size Bc handled. 142 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. c For large trees with n>w nodes, we divide the first block j1 >jsuch that mj1 143 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. 7 1 2 56 4 44 9 5 1 4 6 7 8 8 3 9 Figure 3: A tree representing the lrm(j) sequences of values m1 ...m9. the i-th 1 left-to-right represents the i-th node upwards to require only O(τ) bits on top of the sequence of in the ladder, and the distance between two 1s, the values [35, 12]. The extra space is thus O(n/wc) bits, weight of the edge between them. All the bitmaps are and it solves any query up to the block granularity. concatenated into one (so each ladder is represented For solving a general query [i, j] we should compare the by a couple of integers indicating the extremes of its minimum/maximum obtained with the result of running bitmap). This long bitmap contains at most 2τ 1s, queries rmqi and RMQi within the blocks at the two and because weights do not exceed W , at most 2τW extremes of the boundary [i, j]. 0s. Using Pˇatra¸scu’s sparse bitmaps [30], it can be For the remaining operations, we define pio- t τWt 3/4 − represented using O(τ log W + t +(τW) ) bits neers [20]. We divide the parentheses sequence P [0, 2n log (τW) c and do rank/select in O(t) time. 1] into blocks of length w . Then we extract pairs (i, j) In addition, we store for each node the log τ accu- of matching parentheses (j = findclose(i)) such that mulated weights towards ancestors at distances 2i, us- i and j belong to different blocks. If we consider a ing fusion trees [15]. These can store z keys of bits graph whose vertex set consists of the blocks and whose in O(z) bits and, using O(z5/6(z1/6)4)=O(z1.5) pre- edge set consists of the pairs of parentheses, the graph is outer-planar. To remove multiple edges, we choose processing time, answer predecessor queries in O(log z) time (via an 1/6-ary tree). The 1/6 can be reduced to the tightest pair of parentheses for each pair of vertices. achieve O(z1+ ) preprocessing time and O(1/) query These parentheses are called pioneers. Because pioneers time for any desired constant 0 <≤ 1/2. correspond to the edges (without multiplicity) of an O c In our case this means O(τ log τ log(τW)) bits outer-planar graph, their number is (n/w ). Further- of space, O(τ log1+ τ) construction time, and O(1/) more, they form another balanced parentheses sequence P representing an ordinal tree with O(n/wc) nodes. access time. Thus we can find in constant time, from each node v, the corresponding weighted ancestor To encode P we use a compressed bit vector − v using a predecessor query. If this corresponds to C[0, 2n 1] such that C[i] = 1 indicates that parenthesis i i+1 P [i] is a pioneer. Using again Pˇatra¸scu’sresult [30], distance 2 , then the true ancestor is at distance < 2 , n c vector C can be represented in at most wc log(w )+ and thus it is within the ladder of v , where it is found t O nt 3/4 using rank/select on the bitmap of ladders (each node ( logt n + n ) bits, so that operations rank and select v has a pointer to its 1 in the ladder corresponding to can be computed in O(t) time. the path it belongs to). For computing child and child-rank, it is enough to consider only nodes which completely include a block (otherwise the query is solved in constant time by To apply this lemma for our problem of computing c n considering just two adjacent blocks). Furthermore, fwd-search outside blocks, we have W = w and τ = wc . among them, it is enough to consider pioneers because n log2 n Then the size of the data structure becomes O( wc + if pair (i, j), with i and j in different blocks, is not a t nt 3/4 2 t +n ). By choosing = min(1/2, 1/c ), the query pioneer, then it must contain a pioneer matching pair log n O 2 O (i ,j ), with i in the same block of i and j in the same time is (c + t) and the preprocessing time is (n) for c ≥ 1.47. block of j.Thusi is a descendant of i and all the children of i start within [i+1,i] or within [j +1,j−1], 5.2 Other operations thus all are contained in two blocks. Hence computing For computing rmqi and RMQi, we use a simple data child(i, q) and child-rank for a child of i can be done in structure [3] on the mr and Mr values, later improved constant time by considering just these two blocks. 144 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. Thus we only need to care about pioneer nodes B in the results, the overall extra space added is 2 t √ n(c log B+log n) nt B 3/4 containing at least one block; let us call marked these O( c + t + 2 + n ) bits. Assuming O c B log n nodes, of which there are only (n/w ). We focus on pessimistically w = log n, setting t = c2, and replacing the children of marked nodes placed at the blocks fully B, we get that the time for any operation is O(c2), and contained in them, as the others lie in at most the two n logc log n the total space simplifies to 2n + O( c−2 ). extreme blocks and can be dealt with in constant time. log n Construction time is O(n). We now analyze the For each marked node v we store a list formed working space for constructing the data structure. We by the blocks fully contained in v, and that contain first convert the input balanced parentheses sequence (starting positions of) children of v. Since each block P into a set of aB-trees, each of which represents a contains children of at most one marked node fully part of the input of length Bc. The working space is containing the block, each block belongs to at most one O(Bc) from Theorem 4.1. Next we compute pioneers: list, and it stores its position in the list it belongs to. n log n We scan P from left to right, and if P [i] is an opening All this data occupies O( c ) bits. In addition, the w parenthesis, we push i in a stack, and if it is closing, contained blocks store the number of children of v that we pop an entry from the stack. Because P is nested, start within them. The sequence of number of children the values in the stack are monotone. Therefore we can formed for each marked node v is stored as gaps between store a new value as the difference from the previous consecutive 1s in a bitmap Cv. All these lists together c one using unary code. Thus the values in the stack contain at most n 0s and O(n/w ) 1s, and thus can can be stored in O(n) bits. Encoding and decoding be stored within the same space bounds of the other the stack values takes O(n) time in total. It is easy to bitmaps in this section. compute pioneers from the stack. Once the pioneers are Using this bitmap child and child-rank can easily be identified, Pˇatra¸scu’scompressed representation [30] of solved using rank and select.Forchild(v, q) on a marked bit vector C is built in O(n) space too, as it also cuts the node v we start using p = rank (Cv, select (Cv,q)). 1 0 bitmap into polylog-sized aB-trees and then computes This tells the position in the list of blocks of v where some directories over just O(n/polylog(n)) values. the q-th child of v lies. Then the answer corre- The remaining data structures, such as the lrm sponds to the q -th minimum within that block, for sequences and tree, the lists of the marked nodes, and q = q − rank0(select1(Cv,p)). For child-rank(u), c the Cv bitmaps, are all built on O(n/B ) elements, thus where v = parent(u) is marked, we start with z = they need at most O(n) bits of space for construction. rank (Cv, select (Cv,pu)), where pu is the position of 0 1 By rewriting c−2−δ as c, for any constant δ>0, we the block of u within the list of v. Then we add to z get our main result on static ordinal trees, Theorem 1.1. the number of minima in the block of u until u − 1. For degree, similar arguments show that we only 6 A simple data structure for dynamic trees need to consider marked nodes, for which we simply O n log n In this section we give a simple data structure for store all the answers within ( wc ) bits of space. Finally, the remaining operations require just rank dynamic ordinal trees. In addition to the previous and select on P , or the virtual bit vectors P1 and P2.We query operations, we add now insertion and deletion can make up a sequence with the accumulated number of internal nodes and leaves. We then consider a more of 1s in each of the τ blocks. The numbers add up to sophisticated representation giving sublogarithmic time O(n) and thus can be represented as gaps of 0s between for almost all of the operations. consecutive 1s in a bitmap, which can be stored within the previous space bounds. Performing rank and select 6.1 Memory management on this bitmap, in time O(t), lets us know in which block We store a 0,1 vector P [0, 2n − 1] using a dynamic must we finish the query, using its range min-max tree. min-max tree. Each leaf of the min-max tree stores a segment of P in verbatim form. The length of each 5.3 The final result segment is restricted to L ≤ ≤ 2L for some parameter Recalling Theorem 4.1, we have O(n/Bc) blocks, for L>0. O w If insertions or deletions occur, the length of a B = ( c log w ). The sum of the space for all the blocks is c segment will change. We use a standard technique for 2n + O√(n/B ), plus shared universal tables that add up to O( 2w) bits. Padding the last block to size exactly dynamic maintenance of memory cells [24]. We regard Bc adds up another negligible extra space. the memory as an array of cells of length 2L each, hence On the other hand, in this section we have extended allocation is easily handled in constant time. We use the results to larger trees of n nodes, adding time L + 1 linked lists sL,...,s2L where si stores all the O(t) to the operations. By properly adjusting w to segments of length i. All the segments with equal length 145 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. i are packed consecutively, without wasting any extra up e(vl) each time we descend to vr. Once we obtain space, in the cells of linked list si. Therefore a cell (of d , we start again at the root and see if j(vl) ≥ i,in length 2L) stores (parts of) at most three segments, which case try first on vl. If the answer is not there or and a segment spans at most two cells. Tree leaves j(vl) 146 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. corresponding subranges. We store (i) the chil- holding the global minimum. For each node holding dren boundaries i,(ii) sφ[1,k] and sψ[1,k] storing the minimum, n(i, j) gives the number of occurrences sφ/ψ[i]=sum(P, φ/ψ, 1,ri), (iii) e[1,k] storing e[i]= of the minimum in the node. Thus we apply r(i, j, 1) sum(P, π, 1,ri), (iv) m[1,k] storing m[i]=e[i − 1] + and n(i, j) O(log n/ log log n) times. Operation child- rmq(P, π, i,ri), and M[1,k] storing M[i]=e[i − 1] + rank is very similar, by changing the right end of the RMQ(P, π, i,ri). Note that the values stored are local interval of interest, as before. Finally, solving child is to the subtree (as in the simpler balanced binary tree also similar, except that when we exceed the desired version) but cumulative with respect to previous sib- rank in the sum (i.e., in some node n(i, j) ≥ t, where lings. Note also that storing sφ, sψ and e is redundant, t is the local rank of the child we are looking for), we as noted in Section 4.3, but we need them in explicit find the desired min-max tree branch with r(i, j, t), and form to achieve constant-time searching into their val- continue until finding the proper leaf with one r(i, j, t) ues. operation per level. Apart from simple accesses, we need to support the By using the dynamic partial sums data struc- following operations within a node: ture [32] and the Super-Cartesian tree [13], we obtain: Lemma 7.1. • p(i): the largest j such that j−1 ≤ i (or j = 1). For a 0,1 vector of length 2n, there ex- ists a data structure using 2n + O(n log log n/ log n) • wφ/ψ(i): the largest j such that sφ/ψ[j − 1] ≤ i (or bits supporting fwd-search and bwd-search in O(log n) j = 1). time, and all other operations (including update) in O(log n/ log log n) time. • f(i, d): the smallest j ≥ i such that m[j] ≤ d ≤ M[j]. In many operations to support, we carry out fwd-search(P, π, i, d)orbwd-search(P, π, i, d) for a small • b(i, d): the largest j ≤ i such that m[j] ≤ d ≤ M[j]. constant d. Those particular cases can be made more efficient. • r(i, j, t): the t-th x such that m[x] is minimum in m[i, j]. Lemma 7.2. For a 0,1 vector P , fwd-search(P, π, i, d) and bwd-search(P, π, i, d) can be computed in O(d + • R(i, j, t): the t-th x such that M[x] is maximum in log n/ log log n) time. M[i, j]. The proofs will be given in the full paper. • n(i, j): the number of times the minimum occurs This completes our main result in this section, in m[i, j]. Theorem 1.2. • update: updates the data structure upon ±1 8 Concluding remarks changes in some child. In this paper we have proposed flexible and powerful Operations fwd-search /bwd-search can then be data structures for the succinct representation of ordinal carried out via O(log n/ log log n) applications of trees. For the static case, all the known operations are f(i, d)/b(i, d). Recalling Lemma√ 4.1, the interval of done in constant time using 2n + O(n/polylog(n)) bits interest is partitioned into O( log n · log n/ log log n) of space, for a tree of n nodes. This largely improves nodes of the B-tree, but these can be grouped into the redundancy of previous representations, by building O(log n/ log log n) sequences of siblings. Within each on a recent result [30]. The core of the idea is the range such sequence a single f(i, d)/b(i, d) operation is suf- min-max tree, which has independent interest. This ficient. Once the answer of interest j is finally found simple data structure reduces all of the operations to within some internal node, we descend to its j-th a handful of primitives, which run in constant time on child and repeat the search until finding the cor- polylog-sized subtrees. It can be used in standalone rect leaf, again in O(log n/ log log n) applications of form to obtain a simple and practical implementation f(i, d)/b(i, d). Operations rmqi and RMQi are solved that achieves O(log n) time for all the operations. We in very similar fashion, using O(log n/ log log n) ap- then achieve constant time by using the range min-max plications of r(i, j, 1)/R(i, j, 1). Also, operations rank tree as a building block for handling larger trees. and select on P are carried out in obvious manner For the dynamic case, there have been no data with O(log n/ log log n) applications of p(i) and wφ/ψ(i). structures supporting several of the usual tree opera- Handling φ for P1 and P2 is immediate; we omit it. tions. The data structures of this paper support all of For degree we partition the interval as for rmqi the operations, including node insertion and deletion, and then use m[r(i, j, 1)] in each node to identify those in O(log n) time, and a variant supports most of them 147 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. in O(log n/ log log n) time. They are based on dynamic [12] J. Fischer and V. Heun. A new succinct representa- range min-max trees, and especially the former is ex- tion of RMQ-information and improvements in the en- tremely simple and can be easily implemented. hanced suffix array. In Proc. 1st International Sympo- Future work includes reducing the time complex- sium on Combinatorics, Algorithms, Probabilistic and ities for all of the operations in the dynamic case to Experimental Methodologies (ESCAPE), LNCS 4614, O(log n/ log log n), as well as trying to improve the re- pages 459–470, 2007. [13] J. Fischer and V. Heun. Range median of minima dundancy (this is O(n/ log n) for the simpler structure O queries, super-cartesian trees, and text indexing. In and (n log log n/ log n) for the more complex one). Proc. 19th International Workshop on Combinatorial Algorithms (IWOCA), pages 239–252, 2008. Acknowledgments [14] M. Fredman and M. Saks. The Cell Probe Complexity We thank Mihai Pˇatra¸scufor confirming us the con- of Dynamic Data Structures. In Proc. 21st Annual struction cost of his aB-tree and rank/select data struc- ACM Symposium on Theory of Computing (STOC), ture [30]. pages 345–354, 1989. [15] M. Fredman and D. Willard. Surpassing the infor- mation theoretic bound with fusion trees. Journal of References Computer and Systems Science, 47(3):424–436, 1993. [16] R. F. Geary, N. Rahman, R. Raman, and V. Raman. A simple optimal representation for balanced paren- [1] D. Arroyuelo. An improved succinct representation for theses. In Proc. 15th Annual Symposium on Combi- dynamic k-ary trees. In Proc. 19th Annual Symposium natorial Pattern Matching (CPM), LNCS 3109, pages on Combinatorial Pattern Matching (CPM), LNCS 159–172, 2004. 5029, pages 277–289, 2008. [17] R. F. Geary, R. Raman, and V. Raman. Succinct ordi- [2] J. Barbay, J. I. Munro, M. He, and S. S. Rao. Succinct nal trees with level-ancestor queries. In Proc. 15th An- indexes for strings, binary relations and multi-labeled nual ACM-SIAM Symposium on Discrete Algorithms trees. In Proc. 18th Annual ACM-SIAM Symposium (SODA), pages 1–10, 2004. on Discrete Algorithms (SODA), pages 680–689, 2007. [18] A. Golynski, R. Grossi, A. Gupta, R. Raman, and S. S. [3] M. Bender and M. Farach-Colton. The LCA problem Rao. On the size of succinct indices. In Proc. 15th revisited. In Proc. 4th Latin American Symposium on Annual European Symposium on Algorithms (ESA), Theoretical Informatics (LATIN), LNCS 1776, pages pages 371–382. LNCS 4698, 2007. 88–94, 2000. [19] M. He, J. I. Munro, and S. S. Rao. Succinct ordinal [4] M. Bender and M. Farach-Colton. The level ancestor trees based on tree covering. In Proc. 34th Interna- problem simplified. Theoretical Computer Science, tional Colloquium on Automata, Languages and Pro- 321(1):5–12, 2004. gramming (ICALP), LNCS 4596, pages 509–520, 2007. [5] D. Benoit, E. D. Demaine, J. I. Munro, R. Raman, [20] G. Jacobson. Space-efficient static trees and graphs. In V. Raman, and S. S. Rao. Representing trees of higher Proc. 30th IEEE Annual Symposium on Foundations of degree. Algorithmica, 43(4):275–292, 2005. Computer Science (FOCS), pages 549–554, 1989. [6] H.-L. Chan, W.-K. Hon, T.-W. Lam, and K. Sadakane. [21] J. Jansson, K. Sadakane, and W.-K. Sung. Ultra- Compressed indexes for dynamic text collections. ACM succinct representation of ordered trees. In Proc. Transactions on Algorithms, 3(2):article 21, 2007. 18th Annual ACM-SIAM Symposium on Discrete Al- [7] Y.-T. Chiang, C.-C. Lin, and H.-I. Lu. Orderly gorithms (SODA), pages 575–584, 2007. spanning trees with applications. SIAM Journal on [22] H.-I. Lu and C.-C. Yeh. Balanced parentheses strike Computing, 34(4):924–945, 2005. back. ACM Transactions on Algorithms (TALG), [8] O. Delpratt, N. Rahman, and R. Raman. Engineering 4(3):article 28, 2008. the LOUDS succinct tree representation. In Proc. 5th [23] V. M¨akinen and G. Navarro. Dynamic entropy- Workshop on Efficient and Experimental Algorithms compressed sequences and full-text indexes. ACM (WEA), pages 134–145. LNCS 4007, 2006. Transactions on Algorithms (TALG), 4(3):article 32, [9] A. Farzan and J. I. Munro. A uniform approach 2008. towards succinct representation of trees. In Proc. [24] J. I. Munro. An implicit data structure supporting in- O n 11th Scandinavian Workshop on Algorithm Theory sertion, deletion, and search in (log ) time. Journal (SWAT), LNCS 5124, pages 173–184, 2008. of Computer System Sciences, 33(1):66–74, 1986. [10] P. Ferragina, F. Luccio, G. Manzini, and S. Muthukr- [25] J. I. Munro. Tables. In Proc. 16th Foundations of Soft- ishnan. Structuring labeled trees for optimal succinct- ware Technology and Computer Science (FSTTCS), ness, and beyond. In Proc. 46th IEEE Annual Sym- LNCS 1180, pages 37–42, 1996. posium on Foundations of Computer Science (FOCS), [26] J. I. Munro and V. Raman. Succinct representation of pages 184–196, 2005. balanced parentheses and static trees. SIAM Journal [11] J. Fischer. Optimal succinctness for range minimum on Computing, 31(3):762–776, 2001. queries. CoRR, abs/0812.2775, 2008. [27] J. I. Munro, V. Raman, and S. S. Rao. Space efficient 148 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited. suffix trees. Journal of Algorithms, 39(2):205–222, 2001. [28] J. I. Munro, V. Raman, and A. J. Storm. Represent- ing dynamic binary trees succinctly. In Proc. 15th An- nual ACM-SIAM Symposium on Discrete Algorithms (SODA), pages 529–536, 2001. [29] J. I. Munro and S. S. Rao. Succinct representations of functions. In Proc. 31th International Colloquium on Automata, Languages and Programming (ICALP), LNCS 3142, pages 1006–1015, 2004. [30] M. Pˇatra¸scu. Succincter. In Proc. 49th IEEE An- nual Symposium on Foundations of Computer Science (FOCS), pages 305–313, 2008. [31] M. Pˇatra¸scu and M. Thorup. Time-space trade-offs for predecessor search. In Proc. 38th Annual ACM Symposium on Theory of Computing (STOC), pages 232–240, 2006. [32] R. Raman, V. Raman, and S. S. Rao. Succinct dy- namic data structures. In Proc. 7th Annual Workshop on Algorithms and Data Structures (WADS), LNCS 2125, pages 426–437, 2001. [33] R. Raman, V. Raman, and S. S. Rao. Succinct indexable dictionaries with applications to encoding k- ary trees and multisets. In Proc. 13th Annual ACM- SIAM Symposium on Discrete Algorithms (SODA), pages 233–242, 2002. [34] R. Raman and S. S. Rao. Succinct dynamic dictionar- ies and trees. In Proc. 30th International Colloquium on Automata, Languages and Programming (ICALP), LNCS 2719, pages 357–368, 2003. [35] K. Sadakane. Compressed Suffix Trees with Full Func- tionality. Theory of Computing Systems, 41(4):589– 607, 2007. 149 Copyright © by SIAM. Unauthorized reproduction of this article is prohibited.