Succinct Indices for Path Minimum, with Applications to Path Reporting

Transcription

1 Succinct Indices for Path Minimum, with Appications to Path Reporting Timothy M. Chan 1, Meng He 2, J. Ian Munro 1, and Gein Zhou 1 1 David R. Cheriton Schoo of Computer Science, University of Wateroo, Canada. {tmchan, imunro, g5zhou}@uwateroo.ca 2 Facuty of Computer Science, Dahousie University, Canada. mhe@cs.da.ca Abstract. In the path minimum query probem, we preprocess a tree on n weighted nodes, such that given an arbitrary path, we can ocate the node with the smaest weight aong this path. We design nove succinct indices for this probem; one of our index structures supports queries in O(α(m, n)) time, and occupies O(m) bits of space in addition to the space required for the input tree, where m is an integer greater than or equa to n and α(m, n) is the inverse-ackermann function. These indices give us the first succinct data structures for the path minimum probem, and aow us to obtain new data structures for path reporting queries, which report the nodes aong a query path whose weights are within a query range. We achieve three different time/space tradeoffs for path reporting by designing (a) an O(n)-word structure with O(g ϵ n + occ g ϵ n) query time, where occ is the number of nodes reported; (b) an O(n g g n)-word structure with O(g g n + occ g g n) query time; and (c) an O(n g ϵ n)- word structure with O(g g n+occ) query time. These tradeoffs match the state of the art of two-dimensiona orthogona range reporting queries [8] which can be treated as a specia case of path reporting queries. When the number of distinct weights is much smaer than n, we further improve both the query time and the space cost of these three resuts. 1 Introduction As one of the most fundamenta structures in computer science, trees have been widey used in modeing and representing different types of data in numerous computer appications. In many cases, objects are represented by nodes and their properties are characterized by weights assigned to nodes. Researchers have studied the probems of maintaining a weighted tree, such that various types of path queries can be computed efficienty [1, 9, 24, 25, 23, 6, 20, 28, 22, 11]. In this paper, we consider path minimum (maximum) queries and path reporting queries. Path minimum(maximum): Given nodes u and v, return the minimum (maximum) node aong the path from u to v, i.e., the node aong the path whose weight is the minimum (maximum) one; This work was supported by NSERC and the Canada Research Chairs Program. Part of the first author s work was done during his visit to the Department of Computer Science and Engineering, Hong Kong University of Science and Technoogy.

2 Path reporting: Given nodes u and v aong with a range [p, q], report the nodes aong the path from u to v whose weights are between p and q. When the given tree is a path, the above queries become range minimum (maximum) queries [14, 11] and two-dimensiona orthogona range reporting queries [8], respectivey. As stated in [20], the path queries we consider generaize these fundamenta range queries to weighted trees. In this paper, we represent the input tree as an ordina one, i.e., a rooted tree in which sibings are ordered. The weights of nodes are assumed to be drawn from [1..σ]. We use g to denote the base-2 ogarithm and use ϵ to denote a constant in (0, 1). Uness otherwise specified, the underying mode of computation is the standard word RAM mode with word size w = Ω(g n). Path minimum. The probem of supporting path minimum queries has been heaviy studied [1, 9, 2, 29, 23, 6, 11]. Unike our formuation, previous work considers trees on weighted edges instead of weighted nodes. However, it is not hard to see that these two formuations are equivaent. The minimum spanning tree verification probem is a specia offine case of the path minimum probem, for which one shoud determine whether a given spanning tree is minimum. This probem can be soved using O(n + m) comparisons and inear overhead under the word RAM mode [24]. The onine version of this probem, i.e., the path minimum probem, was considered by Aon and Schieber [1]. In the pointer machine mode, they designed a structure that uses super-inear space. Concurrenty, Chazee [9] presented a inear space data structure under word RAM. Both structures require O(α(n)) query time to sum up weights aong a given path, where α(n) is the inverse-ackermann function, and weights are drawn from a semigroup. Thus the onine version of the path minimum probem can aso be supported in the same time and space. More recenty, severa soutions using O(n) words, i.e., O(n g n) bits, with O(1) query time have been designed under word RAM [2, 23, 6, 11]. Pettie [29] studied the ower bound in terms of comparisons of edge weights, and showed that Ω(q α(q, n)+n) comparisons are necessary to serve q queries over a tree of size n. In this paper we present ower and upper bounds for path minimum queries. In Lemma 4 we show that Ω(n g n) bits of space are necessary to encode the answers to path minimum queries over a tree of size n. This distinguishes path minimum queries from range minimum queries in terms of space cost. We adopt the indexing mode (aso caed the systematic mode) [3, 7, 5] in designing new data structures for path minimum queries. Appying this mode to weighted trees, we assume that weights are represented in an arbitrary given raw form; the ony requirement is that the given data support access to the weight of a node given its preorder rank. Auxiiary data structures caed indices are then constructed, and query agorithm uses indices and the access operator provided for the raw data. Not ony is this an important theoretica mode (its variants are frequenty used to prove ower bounds [12, 26, 17]), it is aso of practica importance as it addresses cases in which the (arge) raw data are stored in sower externa memory or even remotey, whie the (smaer) indices coud be stored in memory or ocay. The space of an index is caed additiona space. Note

3 that the ower bound in the previous paragraph is proved under the encoding mode, and thus does not appy to the indexing mode. To present our resuts, we assume the foowing definition for the Ackermann function: A 0 (i) = i + 1 and A +1 (i) = A (i+1) (i + 8), where A (0) (i) = i and A (i) (j) = A (A (i 1) (j)) for i 1. This is faster growing than the one defined by Cormen et a. [10]. Let α(m, n) be the smaest L such that A L ( m/n ) > n, and α(n) be α(n, n). The foowing theorem presents our indices for path minimum: Theorem 1. An ordina tree on n weighted nodes can be indexed (a) using O(m) bits of space to support path minimum queries in O(α(m, n)) time and O(α(m, n)) accesses to the weights of nodes, for any m n; or (b) using 2n+o(n) bits of space to support path minimum queries in O(α(n)) time and O(α(n)) accesses to the weights of nodes. To better understand variant (a) of this resut, we discuss the time and space costs for the foowing possibe vaues of m. When m = n, then we have an index of O(n) bits that supports path minimum queries in O(α(n)) time. When m = O(n(g ) n), for exampe, then it is we-known that α(m, n) = O(1), and thus we have an index of O(n(g ) n) 1 bits that supports path minimum queries in O(1) time. Previous soutions [2, 23, 6, 11] to the same probem with constant query time occupy Ω(n g n) bits of space in addition to the space required for the input tree. Combining the above resuts with a trivia encoding of node weights, we obtain the first succinct data structures for path minimum queries. With a itte extra work, we can even represent a weighted tree using n g σ + 2n + o(n) bits ony, i.e., within an o(n) additive term of the information-theoretic ower bound, to support queries in O(α(n)) time. Considering the construction time is O(n), this variant amost matches the ower bound of Pettie [29]. Path reporting. Path reporting queries were proposed by He et a. [20]. They obtained two soutions: one uses O(n) words and O(g σ + occ g σ) query time, and the other uses O(n g g σ) words but O(g σ + occ g g σ) query time, where σ is the number of distinct weights and occ is output size. For the same probem, Pati et a. [28] designed a succinct structure based on heavy path decomposition [31, 18]. Their structure requires ony n g σ+6n+o(n g σ) bits but O(g σ g n+occ g σ) time. Concurrenty, He et a. [22] designed another succinct structure based on a different idea. This structure, requiring O(g σ/ g g n+occ g σ/ g g n) query time, is the best previousy known inear space soution. In this paper, we design three new data structures for path reporting queries: Theorem 2. An ordina tree on n nodes whose weights are drawn from a set of σ distinct weights can be represented using O(n g σ s(σ)) bits of space, such that path reporting queries can be supported in O(min{g g σ + t(σ), g σ/ g g n} + occ min{t(σ), g σ/ g g n}) time, where occ is the size of output, and s(σ) and t(σ) are: (a) s(σ) = O(1) and t(σ) = O(g ϵ σ); (b) s(σ) = O(g g σ) and t(σ) = O(g g σ); or (c) s(σ) = O(g ϵ σ) and t(σ) = O(1). 1 (g ) is the number of times g must be iterativey appied before the resut becomes ess than or equa to 1.

4 These resuts competey subsume amost a previous resuts; the ony exceptions are the succinct data structures for this probem designed in previous work, whose query times are worse than our inear-space soution. Furthermore, our data structures match the state of the art of 2D range reporting queries [8] when σ = n, and have better performance when σ is much ess than n. Overview of Techniques. Unike previous succinct tree structures [16, 28, 22, 19, 13], our approach for path minimum is based on topoogica partitions [15] which transform the input tree into a binary tree and further recursivey decomposes it into a hierarchy of custers with constant externa degrees. Our main strategy of constructing path minimum query structures (in Section 3) is to recursivey divide the set of eves of decomposition into mutipe subsets of eves; with a carefuy-defined version of the path minimum query probem which takes eves in the decomposition as parameters, the query over the entire structure can be answered by conquering the subprobems oca to the subsets of eves. Soutions to specia cases of the query probem are aso designed, so that we can present the time and space costs of our soution using recursive formuas. Then, by carefuy constructing a number series and using it in the division of eves into subsets, we can prove that our structures achieve the tradeoff presented in Theorem 1 using the inverse-ackermann function. This approach is nove and exciting, and it does not directy use standard techniques for word RAM at a. The above strategy woud not achieve the desired space bound without a succinct data structure that supports navigations in the input tree, the binary tree that it is transformed into and the custers in the topoogica partition. We design such a structure (in Section 4) occupying ony 2n + o(n) bits, which is of independent interest. Finay, to design soutions to path reporting (in Section 5), we foow the genera framework of He et a. [22] to extract subtrees based on the partitions of the entire weight range, and make use of a conceptua structure that borrows ideas from the cassica range tree. One strategy of achieving improved resuts is to further reduce path reporting into queries in which the weight ranges are one-sided, which aows us to appy our succinct index for path minimum queries to achieve the tradeoffs presented in the second haf of the abstract. We further appy a tree covering strategy to reduce the space cost for the case in which the number of distinct weights is much smaer than n, and hence prove Theorem 2. 2 Preiminaries Succinct Data Structures. Bit vectors are one of the main buiding bocks in many space efficient data structures. Let B[1..n] denote a bit vector of size n. For α {0, 1}, rank α (B, i) counts α-bits in B[1..i], whie seect α (B, i) finds the i-th α-bit in B. The foowing emma presents succinct bit vector representations: Lemma 1 ([30]). A bit vector with n m zeros and m ones can be represented using g ( n m) + O(n g g n/ g n) bits of space to support rankα, seect α, and the access to each bit in constant time.

5 The next emma presents succinct ordina trees over an aphabet of size σ = o(g g n), and unabeed trees can be considered as a specia case: Lemma 2 ([16, 19, 13]). An ordina tree T on n nodes over an aphabet of size σ can be encoded in n(g σ + 2) + O(σn g g g n/ g g n) bits of space to support the foowing operations in O(1) time. Here x and y, which are nodes in T, are identified by preorder ranks. A node is its own 0-th ancestor. In addition, a node with abe α is an α-node, and an α-node is an α-ancestor of its descendants. depth(t, x): the depth of x (i.e., the number of ancestors of x); depth α (T, x): the number of α-ancestors of x; parent(t, x): the parent of x; eve anc(t, x, i): the i-th owest ancestor of x; eve anc α (T, x, i): the i-th owest α-ancestor of x; LCA(T, x, y): the owest common ancestor of x and y. Topoogica Partitions and Topoogy Trees. Frederickson [15] presented topoogica partitions for onine updating of minimum spanning trees. An input tree T, which may have arbitrary degree, is transformed into a binary tree B; and then B is partitioned as foows: Lemma 3 ([15]). A binary tree B on n nodes can be partitioned into a hierarchy of custers with h + 1 eves for some h = O(g n): each custer is a connected component of B; the ony custer at eve h contains a the nodes in B, and each custer at eve 0 contains a singe node; a custer at eve i > 0 is the disjoint union of at most 4 custers at eve i 1; at eve i, there are at most (3/4) i n custers of size at most 4 i, which form a partition of the nodes in the binary tree; and each custer has at most 3 nodes that are connected to the outside, which are caed its endpoints. The hierarchy of custers is referred to as the topoogy tree of T and B, which is denoted by H. A node at eve i > 0 of H represents a custer C at eve i of the hierarchy, and its chidren represent the custers at the ower eve that partition C. In particuar, the eaf nodes of H, which are at eve 0, represent individua nodes of the binary tree B. Tree Extraction. He et a. [20, 22] introduced tree extraction to support path queries. This technique is based on the deetion operation of tree edit distance [4]. To deete a non-root node u, its chidren are inserted in pace of u into the ist of chidren of its parent, preserving the origina eft-to-right order. Let T be an ordina tree and X be a subset of nodes in T. The X-extraction of T, F X, is defined to be the ordina forest obtained by deeting a the nodes that are not in X from T. There is a natura one-to-one correspondence between the nodes in X and the nodes in F X, and the ancestor-descendant and preorder reationships among the remaining nodes are preserved. If X contains the root of T, then F X consists of a singe ordina tree ony, which is denoted by T X.

6 3 Path Minimum Queries We first give a simpe ower bound for path minimum queries under the encoding mode. Due to page imitation, the proof is omitted here. Lemma 4. In the worst case, Ω(n g n) bits are required to encode the answers to a possibe path minimum queries over a tree on n weighted nodes. Unike the ower bound of Pettie [29], Lemma 4 provides a separation between path minimum and range minimum in terms of space: Ω(n g n) bits are required to encode path minimum queries over a tree on n weighted nodes, whie range minimum over an array of ength n can aways be encoded in 2n bits [14]. Now we consider the support for path minimum queries. The space cost of maintaining a weighted tree is dominated by storing the weights of nodes. Thus we represent the input tree as an ordina one, for which the nodes are identified by their preorder ranks. This does not significanty affect the space cost. We wi assume the indexing mode described in Section 1 and deveop severa nove succinct indices for path minimum queries. Thus the weights of nodes are assumed to be stored separatey from the index for queries, and can be accessed with the preorder ranks of nodes. The time cost to answer a given query is measured by the number of accesses to the index and that to node weights. Let T be an input tree on n nodes. Here T is represented as an ordina one, and its nodes are identified by preorder ranks. We transform T into a binary tree B as foows (essentiay as in the usua way but with added dummy nodes): For each node u with d > 2 chidren, where v 1, v 2,, v d are chidren of u, we add d 2 dummy nodes x 1, x 2,, x d 2. The first and the second chid of u are set to be v 1 and x 1, respectivey. For 1 k < d 2, the first and the second chid of x k are set to be v k+1 and x k+1, respectivey. Finay, the first and the second chid of x d 2 are set to be v d 1 and v d, respectivey. In this way we have repaced u and its chidren with a right-eaning binary tree, where the eaf nodes are chidren of u. This transformation does not change the preorder reationship among the nodes in T. In addition, the set of non-dummy nodes aong the path between any two non-dummy nodes remain the same after transformation. We decompose B and obtain the topoogy tree H using Lemma 3. For simpicity, a custer at eve i is caed a eve-i custer, and its endpoints are caed eve-i endpoints. Since T and B are both rooted trees, each custer contains a node that is the ancestor of a the other nodes in the same custer. This node is referred to as the root of the custer. In the topoogy tree H, sibing custers are ordered by the preorder ranks of their roots. Each custer C is identified by its topoogica rank, i.e., the preorder rank of the node in H that represents C. To faciitate the use of topoogy trees, we define operations reevant to nodes, custers and endpoints. Here we assume that x and y are nodes in B. conversions between nodes in B and T ; eve custer(h, i, x): the eve-i custer that contains node x; LCC(H, x, y): the owest-eve custer C that contains nodes x and y; custer root(h, C): the root of eve-i custer C;

7 custer endpoints(h, C): the endpoints of eve-i custer C; cosest endpoint(h, C, x): the endpoint of C that is the cosest to node x, given that x is outside of C; parent(b, x): the parent node of x; LCA(B, x, y): the owest common ancestor of x and y; endpoint rank(b, i, x): the number of eve-i endpoints preceding x in preorder of B; endpoint seect(b, i, j): the j-th eve-i endpoint in preorder of B. Lemma 5. Let T be an ordina tree on n nodes. Then T, the transformed binary tree B, and their topoogy tree H can be encoded in 2n + o(n) bits of space such that the operations isted above can be supported in O(1) query time. To present our key strategy first, we defer the proof of Lemma 5 to Section 4. As the conversion between nodes in T and B can be performed in O(1) time, we assume that each given query is specified by two nodes in B. Let h denote the highest eve of H. The foowing two query probems are defined in terms of custers and endpoints, for 0 i < j h: P i,j (C 0, C 1, C 2 ): find the minimum node aong the path from an endpoint of a eve-i custer C 1 to an endpoint of another eve-i custer C 2, where both C 1 and C 2 are contained in the same eve-j custer C 0 ; P i,j (C 0, C 1 ): find the minimum node aong the path from an endpoint of a eve-i custer C 1 to an endpoint of a eve-j custer C 0, where C 1 is in C 0. For simpicity, we drop the parameters when referring to these probems in the rest of this section. Thus the origina probem is P 0,h. If P i,j is soved, then P i,j and P i,j for i > i are aso naturay soved. Let h 0 > 0 be a parameter whose vaue wi be determined ater. We wi sove P 0,h0 using brute-force search, and support P h0,h using a nove recursive approach as described beow. For each custer C whose eve is higher than or equa to h 0, we expicity store the minimum node on the bridges of C, where bridges are paths connecting pairs of endpoints of C (excuding the endpoints). This requires 6i bits for a custer at eve i, as it has at most three bridges. The overa space cost is h i=h 0 ( 6i (3/4) i n ) = O(h 0 (3/4) h0 n) bits, which is o(n) bits when h 0 = ω(1). We have the foowing emmas as base cases of recursion. Lemma 6. For i h 0, P i,i+8 can be soved in O(1) query time and 0 extra bits. The correctness of this emma foows from the fact that each eve-(i + 8) custer contains a constant number of eve-i custers, which makes it possibe to spit a query path into a constant number of subpaths, each being either a eve-i endpoint or a bridge of some eve-i custer which have been preprocessed. Lemma 7. P i,j can be soved using O(1) query time and O((3/4)i n) extra bits. Proof. We construct an ordina tree T i by extracting a eve-i endpoints from B. The size of T i is O((3/4) i n). For convenience, we denote a node in T i by u iff it corresponds to a eve-i endpoint u in B. The conversion between u and u

8 can be performed in O(1) time using endpoint rank and endpoint seect. Next we assign abes from aphabet {0, 1} to the nodes of T i. We ony consider the case in which the eve-j endpoint is the first one in preorder of its custer; the other cases can be handed simiary. Let u be any eve-i endpoint and et v be the first endpoint of C 0 = eve custer(b, j, u), i.e., the eve-j custer that contains u. Like the proof of Lemma 6, the path from u to v in B can be spit into a sequence of eve-i endpoints and bridges of eve-i custers. Let x be the next eve-i endpoint on the path. We assign 1 to u in T i if the minimum node between u and v is smaer than that between x and v; otherwise we assign 0 to u. We represent this abeed tree in O((3/4) i n) bits using Lemma 2. To find the minimum node between u and v, we need ony find the cosest 1-node to u aong the path from u to v in T i. This can be done in O(1) time by performing eve anc α and depth α operations on T i. Let x be such a node. Then the minimum node between u and v must be x or appear on some bridge of the eve-i custer that contains x, and thus can be retrieved in O(1) time. Now we turn to consider genera P i,j, for which we wi deveop a recursive strategy with mutipe iterations. At each iteration, we pick a sequence i = i 0 < i 1 < i 2 <... < i k = j, for which P i0,i 1, P i1,i 2,..., P ik 1,i k are assumed to be soved at the previous iteration. By Lemma 7, we sove P i,i 1, P i,i 2,..., P i,i k using O(k(3/4) i n) bits of additiona space. Consider the support for a query of P i,j, for which eve-i endpoints u and t are endpoints of the query path, and u and t are contained in the same eve-j custer. W..o.g, we assume that t is an ancestor of u (the case in which neither node is an ancestor of the other can be reduced to this case easiy). We compute C 0 = LCC(B, u, t), which is the owest eve custer that contains both u and t. Let i be the eve of C 0. Then we determine s such that i s < i i s+1 ; s can be computed in constant time by precomputing the resut for each of the h + 1 = O(g n) eves. Let C 1 be the eve-i s custer that contains u and et x be an endpoint of C 1 that is between u and t. Simiary, et C 2 be the eve-i s custer that contains t and et z be an endpoint of C 2 that is between u and t. Note that x and z can be found in constant time using eve custer and cosest endpoint. Thus the query path can be decomposed into u x z t. The minimum node on u x and that on z t can be found by querying P i,i s. The minimum node on x z can be found by recursivey querying P is,i s+1. Summarizing the discussion above, we have the foowing recurrences. Here is the number of iterations, and Q (i, j) and S (i, j) are time and space costs for soving P i,j at the -th iteration. k 1 S +1 (i, j) = S (i s, i s+1 ) + O(k(3/4) i n) (1) s=0 Q +1 (i, j) = k 1 max s=0 Q (i s, i s+1 ) + O(1) (2) Lemma 8. Given a fixed vaue L, there exists a recursive strategy and some constant c such that, for 0 L, S (i, A (i)) c(4/5) i n and Q (i, A (i)) c.

9 Proof. At the 0-th iteration, we have A 0 (i) = i + 1. This can be used as the base case. By Lemma 6, P i,i+1 can be supported using constant query time at no extra space cost. Thus the statement hods for = 0. At the ( + 1)-th iteration, we choose the sequence i, i + 8, A (i + 8), A (2) (i + 8),..., A (i) (i + 8), A(i+1) (i + 8). The ast term is A +1 (i). Then by Equation 1: S +1 (i, A +1 (i)) 0 j i S (A (j) (i + 8), A (j+1) (i + 8)) + O(i(3/4) i n) O(i(3/4) i n) + 0 j i c(4/5) A(j) (i+8) n O(i(3/4) i n) + 5c(4/5) i+8 n c(4/5) i n for some sufficienty arge constant c. This convergence foows because 5(4/5) 8 is ess than 1. Equation 2 impies Q +1 (i, A +1 (i)) O(1) + max 0 j i Q (A (j) (i + 8), A (j+1) (i+8)) O(1)+c c(+1) for some sufficienty arge c. The induction thus carries through. To achieve desired time-space tradeoffs, we recurse one more iteration. Given a parameter m n, we set L = α(m, n) and h 0 = 0. At the fina (L + 1)-th iteration, choose the sequence 0, 1, 2,..., m/n, A L ( m/n ). This gives S L+1 (0, A L ( m/n )) S L ( m/n, A L ( m/n )) + O( m/n n) O(m) and Q L+1 (0, A L ( m/n )) O(L) = O(α(m, n)). Thus we have proved part (a) of Theorem 1. To further decrease the space cost of our index to 2n + o(n) bits, we sti recurse L eves. We choose L = α(n) and h 0 = og 4 L. Note that h 0 = ω(1) and A L (h 0 ) h. Therefore we have S L (h 0, A L (h 0 )) = O((4/5) h 0 n) = o(n), and Q L (h 0, A L (h 0 )) = O(L) = O(α(n)). To sove P 0,h0 and P 0,h 0, we perform bruteforce search on the query path in O(4 h 0 ) = O(α(n)) time, as a eve-h 0 custer has at most 4 h0 nodes. Thus we have proved part (b) of Theorem 1. By further constructing the preorder abe sequence [22, 21] of T, we have: Coroary 1. Let T be an ordina tree on n nodes, each having a weight drawn from [1..σ]. Then T can be represented (a) using n g σ + O(m) bits of space to support path minimum queries in O(α(m, n)) time, for any m n; or (b) using n(g σ+2)+o(n) bits of space to support path minimum queries in O(α(n)) time. 4 Encoding Topoogy Trees Let T be an ordina tree on n nodes. As described in Section 3, we transform T into a binary tree B, and compute the topoogy tree of B as H. Let n H denote the number of nodes in H; ceary n H = O(n). Let i 1 = 8 g g n and i 2 = (1/2) g g n 1. By Lemma 3, there are at most n 1 = (3/4) i 1 n = O(n/(4/3) 8 g g n ) = O(n/ g 8 g(4/3) n) < O(n/ g 3 n) custers at eve i 1, each

10 being of size at most m 1 = 4 i g g n+1 = 4 g 16 n. Simiary, there are at most n 2 = (3/4) i2 n = O(n/ g (1/2) g(4/3) n) < O(n/(g 1/5 n)) custers at eve i 2, each being size of at most m 2 = 4 i 2 4 (1/2) g g n 1 = (g n)/4. Leve-i 1 custers are caed mini-custers, and eve-i 2 ones are caed micro-custers. We first store the encodings of micro-custers. Lemma 9. A micro-custers can be encoded in 2n + o(n) bits of space such that given the topoogica rank of a custer, its encoding can be retrieved in O(1) time if it is a micro-custer. Proof. Note that B has at most 2n nodes. Given a micro-custer C, we do not store its encoding directy because it coud require about 4n bits of space for a micro-custers. Instead, we define X to be the union of non-dummy nodes and endpoints of C and store ony C X, where C X is the X-extraction of C as defined in Section 2. We aso mark the (at most 3) dummy nodes in C X, which requires O(g m 2 ) = O(g g n) bits per node. Encoding C X as baanced parentheses [27], the overa space cost of encoding C is 2n C + O(g g n) bits, where n C is the number of non-dummy nodes in C. We concatenate the above encodings of a micro-custers ordered by topoogica rank and store them in a sequence, P, of n = 2n + O(n g g n/(g 1/5 n)) bits. We construct a sparse bit vector, P, of the same ength, and set P [i] to 1 iff P [i] is the first bit of the encoding of a micro-custer. P can be represented using Lemma 1 in g ( ) n n 2 + O(n g g n/ g n) = O(n g g n/(g 1/5 n)) bits to support rank α and seect α in constant time. We construct another bit vector B 0 [1..n H ], in which B 0 [j] = 1 iff the custer with topoogica rank j is a micro-custer, which has the same asymptotic space cost. To retrieve the encoding of a custer, C, whose topoogica rank is j, we first use B 0 to check if C is a micro-custer. If it is, et r = rank 1 (B 0, j). Then the encoding of C X is P [seect 1 (P, r)..seect 1 (P, r + 1) 1]. To recover C from C X, we need ony foow the procedure described at the beginning of Section 3. This can be done in O(1) time using a ookup tabe F 0 of o(n) bits. To support operations, our main strategy is to encode goba information at eves on or above i 1, information oca to a mini-custer among eves between i 2 and i 1, and ookup tabes for the eves contained in a micro-custer. Extra care is needed as the topoogica order of custers is not the same as the reative order of their roots in preorder. Detais are omitted due to page imitation. 5 A Sketch of Supporting Path Reporting Queries In this section we sketch our improved data structures for path reporting queries. The detais of supporting path reporting queries are deferred to the fu version of this paper. Our soutions present various agorithmic techniques we deveoped to prove Theorem 2, as we as a simpified approach to achieve simiar timespace tradeoffs for the 2D orthogona range reporting probem on an n σ grid. Foowing the approach of He et a. [22], we buid a conceptua range tree on

11 [1..σ] with branching factor f = g ϵ n. We keep spitting ranges unti the bottom eve contains σ eaf ranges. This conceptua range tree has h = og f σ + 1 eves, among which the top eve is the first eve, and the bottom eve is the h-th eve. For each range [a..b] in the conceptua range tree, we obtain F a,b by extracting a nodes whose weights are in [a..b] from T. Each node x in F a,b is assigned a abe between 1 and f, which indicates the chid range at the ower eve that contains the node that corresponds to x. A these F a,b s are maintained in succinct representations such that path reporting queries with respect to abes can be answered in constant time per node. Let u and v be the endpoints of query path and [p..q] be the query range. The agorithm of He et a. [22] traverses the conceptua range tree from top to bottom, and spits [p..q] into O(g σ/ g g n) canonica ranges, each being a singe range, or the union of consecutive sibing ranges in the conceptua range tree. Thus the origina query can be transformed into O(g σ/ g g n) subqueries on different F a,b s. This reativey simpe agorithm requires an overhead of O(g σ/ g g n) time, in addition to O(g σ/ g g n) time per node in the output, since we need convert a node in F a,b to that of T eve by eve. Our new agorithm avoids traversing the conceptua range tree eve by eve. We make use of the ba-inheritance probem, such that, given a node x in some F a,b, we can determine the node in T that corresponds to x much faster than O(g σ/ g g n) time. To support the given query, we first find the owest range [a..b] in the conceptua range tree that competey contains [p..q]. Let [a 1..b 1 ], [a 2..b 2 ],..., [a f..b f ] be the chid ranges of [a..b] in increasing order of eft endpoints. We determine α, β [1..f], such that [a α..b β ] covers [p..q], and β α is minimized. The query range can thus be decomposed into [p..b α ], [a α+1..b β 1 ] and [a β..q]. The support for the second subrange is the same as that of He et a. [22]. For the third subrange, we empoy the succinct index designed in Theorem 1 with m = O(n g n), such that we can enumerate the nodes in F aβ,q that are on the query path in increasing order of weights. For each of them, we use the auxiiary data structures for the ba-inheritance probem to find the corresponding node in T. This procedure is terminated if the weight of the current node is above q. The support for the first subrange is simiar. References 1. Aon, N., Schieber, B.: Optima preprocessing for answering on-ine product queries. Tech. rep., Te Aviv University (1987) 2. Astrup, S., Hom, J.: Improved agorithms for finding eve ancestors in dynamic trees. In: ICALP. pp (2000) 3. Barbay, J., He, M., Munro, J.I., Satti, S.R.: Succinct indexes for strings, binary reations and mutiabeed trees. ACM Transactions on Agorithms 7(4), 52 (2011) 4. Bie, P.: A survey on tree edit distance and reated probems. Theor. Comput. Sci. 337(1-3), (2005) 5. Bringmann, K., Larsen, K.G.: Succinct samping from discrete distributions. In: STOC. pp (2013) 6. Broda, G.S., Davoodi, P., Rao, S.S.: Path minima queries in dynamic weighted trees. In: WADS. pp (2011)

12 7. Broda, G.S., Davoodi, P., Rao, S.S.: On space efficient two dimensiona range minimum data structures. Agorithmica 63(4), (2012) 8. Chan, T.M., Larsen, K.G., Pǎtraşcu, M.: Orthogona range searching on the RAM, revisited. In: Symposium on Computationa Geometry. pp (2011) 9. Chazee, B.: Computing on a free tree via compexity-preserving mappings. Agorithmica 2, (1987) 10. Cormen, T.H., Leiserson, C.E., Rivest, R.L., Stein, C.: Introduction to Agorithms (3. ed.). MIT Press (2009) 11. Demaine, E.D., Landau, G.M., Weimann, O.: On cartesian trees and range minimum queries. Agorithmica 68(3), (2014) 12. Demaine, E.D., López-Ortiz, A.: A inear ower bound on index size for text retrieva. J. Agorithms 48(1), 2 15 (2003) 13. Farzan, A., Munro, J.I.: A uniform paradigm to succincty encode various famiies of trees. Agorithmica 68(1), (2014) 14. Fischer, J., Heun, V.: Space-efficient preprocessing schemes for range minimum queries on static arrays. SIAM J. Comput. 40(2), (2011) 15. Frederickson, G.N.: Data structures for on-ine updating of minimum spanning trees, with appications. SIAM J. Comput. 14(4), (1985) 16. Geary, R.F., Raman, R., Raman, V.: Succinct ordina trees with eve-ancestor queries. ACM Transactions on Agorithms 2(4), (2006) 17. Goynski, A.: Optima ower bounds for rank and seect indexes. Theor. Comput. Sci. 387(3), (2007) 18. Hare, D., Tarjan, R.E.: Fast agorithms for finding nearest common ancestors. SIAM J. Comput. 13(2), (1984) 19. He, M., Munro, J.I., Satti, S.R.: Succinct ordina trees based on tree covering. ACM Transactions on Agorithms 8(4), 42 (2012) 20. He, M., Munro, J.I., Zhou, G.: Path queries in weighted trees. In: ISAAC. pp (2011) 21. He, M., Munro, J.I., Zhou, G.: A framework for succinct abeed ordina trees over arge aphabets. In: ISAAC. pp (2012) 22. He, M., Munro, J.I., Zhou, G.: Succinct data structures for path queries. In: ESA. pp (2012) 23. Kapan, H., Shafrir, N.: Path minima in incrementa unrooted trees. In: ESA. pp (2008) 24. King, V.: A simper minimum spanning tree verification agorithm. Agorithmica 18(2), (1997) 25. Krizanc, D., Morin, P., Smid, M.H.M.: Range mode and range median queries on ists and trees. Nord. J. Comput. 12(1), 1 17 (2005) 26. Mitersen, P.B.: Lower bounds on the size of seection and rank indexes. In: SODA. pp (2005) 27. Munro, J.I., Raman, V.: Succinct representation of baanced parentheses and static trees. SIAM J. Comput. 31(3), (2001) 28. Pati, M., Shah, R., Thankachan, S.V.: Succinct representations of weighted trees supporting path queries. J. Discrete Agorithms 17, (2012) 29. Pettie, S.: An inverse-ackermann type ower bound for onine minimum spanning tree verification. Combinatorica 26(2), (2006) 30. Raman, R., Raman, V., Satti, S.R.: Succinct indexabe dictionaries with appications to encoding k-ary trees, prefix sums and mutisets. ACM Transactions on Agorithms 3(4) (2007) 31. Seator, D.D., Tarjan, R.E.: A data structure for dynamic trees. J. Comput. Syst. Sci. 26(3), (1983)