Succinct Data Structures Kunihiko Sadakane National Institute of Informatics

Succinct Data Structures for Trees Consider only ordered trees Ordered/Unordered trees Child nodes are ordered/not ordered Concerning unordered trees, trees can be regarded as the same if they become the same shape by reordering children Edges are labeled/not labeled Node labels can be represented by edge labels on the edge toward parent nodes

Ordered Trees ordered tree / ordinal tree Rooted trees Children of each node are ordered No labels With edge labels → cardinal tree 2 6 8 1 7 3 5 4

Succinct Representations of Ordered Trees LOUDS (level order unary degree sequence) BP (balanced parentheses) DFUDS (depth first unary degree sequence)

LOUDS Representation [1,2] Degrees of nodes are encoded by unary codes in breadth-first order degree d → 1d0 2n+1 bits for n nodes (matches the lower bound) i-th node is represented by i-th 1 2 3 8 1 7 4 6 5 L 10110111011000000 1 2 3 4 5 6 7 8 LOUDS

Tree Navigational Operations (1) i-th node: select1(L, i) (i  1) firstchild(x) y := select0(rank1(L,x))+1 if L[y] = 0 then 1 else y lastchild(x) y := select0(rank1(L,x)+1)1 2 3 8 1 7 4 6 5 1 2 3 4 5 6 7 8 LOUDS L 10110111011000000

Tree Navigational Operations (2) sibling(x) if L[x+1] = 0 then 1 else x+1 parent(x) = select1(rank0(L,x)) degree(x) = lastchild(x)  firstchild(x) + 1 Merits: supported by only rank/select Demerits: cannot compute subtree sizes 2 3 8 1 7 4 6 5 1 2 3 4 5 6 7 8 LOUDS L 10110111011000000

BP Representation [3] ((()()())(()())) Each node is represented by a pair of matching open and close parentheses 2n bits for n nodes The size matches the lower bound 2 6 8 1 7 3 5 4 P ((()()())(()())) BP

Basic Operations on BP A node is represented by the position of ( findclose(P,i): returns the position of )matching with( at P[i] enclose(P,i): returns the position of ( which encloses ( at P[i] enclose findclose 1 1 2 3 4 5 6 7 8 9 10 11 2 3 11 8 P (()((()())())(()())()) 4 7 9 10 5 6

Tree Navigational Operations parent(v) = enclose(P,v) firstchild(v) = v + 1 sibling(v) = findclose(P,v) + 1 lastchild(v) = findopen(P, findclose(P,v)1) 1 enclose findclose 2 3 8 11 1 2 3 4 5 6 7 8 9 10 11 4 (()((()())())(()())()) 7 9 10 5 6

Number of Descendants (Subtree Size) The size of the subtree rooted at v is subtreesize(v) = (findclose(P,v)v+1)/2 degree (#children) can be computed by repeatedly applying findclose, but it takes time proportional to the number of children 1 2 3 11 1 2 3 4 5 6 7 8 9 10 11 8 P (()((()())())(()())()) 4 7 9 10 5 6

Data Structure for findclose [4] Divide the parentheses sequence into blocks of length B = ½ log n b(p): block number containing p (p): position of parenthesis matching p parenthesis p is said to be far ⇔ b(p)  b((p)) Far open parenthesis p is said to be opening pioneer ⇔ For the far open parenthesis q which is immediately precedes p, b((p))  b((q)) Represent positions of parentheses which match with opening pioneers are represented by 0,1 vector ( ( ) ) ) p (p) (q) q r ( (r)

Lemma: Let  denote the number of blocks Lemma: Let  denote the number of blocks. Then the number of opening pioneers is at most 23. Proof: A graph whose nodes correspond to the blocks and whose edges are (b(p), b((p)) is an outer-planar graph. Opening/closing pioneers form a BP again.  = n/B = 2n/log n ⇒ Length of BP is O(n/log n)

Representing Recursive Structure opening pioneers and their matching parentheses are represented by a 0,1 vector B B is a sparse vector of length 2n with O(n/log n) 1’s Can be represented in O(n log log n/log n) bits ( ( ) ) ) p (p) (q) q r ( (r) P B 0100 0101 0000 0000 0010 1001 P1 ((()))

Let S(n) denote the size of BP representation for an n node tree S(n) = 2n + O(n log log n/log n) + S(O(n/log n)) If the number of nodes becomes O(n/log2 n), a naïve data structure which stores all the answers uses only O(n/log n) bits Therefore S(n) = 2n + O(n log log n/log n)

Algorithm for findclose To compute (p) = findclose(P,p) If p is not far, (p) is computed by a table Find the pioneer p* that immediately precedes p Find (p*) using the BP for pioneers If p is not pioneer, b((p))  b((p*)) The position of (p) is determined from the difference between depths of p and p* p* p (p) (p*) ( ( ) )

References [1] G. Jacobson. Space-efficient Static Trees and Graphs. In Proc. IEEE FOCS, pages 549–554, 1989. [2] O'Neil Delpratt, Naila Rahman, Rajeev Raman: Engineering the LOUDS Succinct Tree Representation. WEA 2006: 134-145. [3] J. I. Munro and V. Raman. Succinct Representation of Balanced Parentheses and Static Trees. SIAM Journal on Computing, 31(3):762–776, 2001. [4] R. F. Geary, N. Rahman, R. Raman, and V. Raman. A simple optimal representation for balanced parentheses. Theoretical Computer Science, 368:231–246, December 2006. [5] J. Ian Munro, Venkatesh Raman, and S. Srinivasa Rao. Space efficient suffix trees. Journal of Algorithms, 39:205–222, 2001. [6] D. Benoit, E. D. Demaine, J. I. Munro, R. Raman, V. Raman, and S. S. Rao. Representing Trees of Higher Degree. Algorithmica, 43(4):275–292, 2005.

[7] J. Jansson, K. Sadakane, and W. -K. Sung [7] J. Jansson, K. Sadakane, and W.-K. Sung. Ultra-succinct Representation of Ordered Trees. In Proc. ACM-SIAM SODA, pages 575–584, 2007. [8] A. Farzan and J. I. Munro. A Uniform Approach Towards Succinct Representation of Trees. In Proc. SWAT, LNCS 5124, pages 173–184, 2008. [9] A. Farzan, R. Raman, and S. S. Rao. Universal Succinct Representations of Trees? In Proc. ICALP, LNCS 5555, pages 451–462, 2009. [10] P. Ferragina, F. Luccio, G. Manzini, and S. Muthukrishnan. Compressing and indexing labeled trees, with applications. Journal of the ACM, 57(1):4:1–4:33, 2009. [11] R. F. Geary, R. Raman, and V. Raman. Succinct ordinal trees with levelancestor queries. ACM Trans. Algorithms, 2:510–534, 2006. [12] H.-I. Lu and C.-C. Yeh. Balanced parentheses strike back. ACM Transactions on Algorithms (TALG), 4(3):No. 28, 2008.