Succinct Data Structures Kunihiko Sadakane National Institute of Informatics

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

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 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*) ( ( ) )

enclose Let (p) = enclose(P,p) If b((p)) = b(p), (p) is found from a table If b((p))  b(p), store those positions also store positions of matching parentheses if there are more than one pairs of parentheses, store only the outermost one Recur for extracted parentheses ( ( (()))( ) ) )

Additional Basic Operations on BP rankp(P,i): number of pattern p in P[1..i] selectp(P,i): position of i-th occurrence of p in P If the length of p is constant, rank/select is done in O(1) time 1 1 2 3 4 5 6 7 8 9 10 11 2 3 11 8 P (()((()())())(()())()) 4 7 9 10 rank()(P,10) = 3 5 6

Operations on Leaves [5] Each leaf is represented by()in BP Position of i-th leaf = select()(P, i) Number of leaves in a subtree, leftmost/rightmost leaf in a subtree are also found 1 1 2 3 4 5 6 7 8 9 10 11 2 3 11 8 P (()((()())())(()())()) 4 7 Subtree rooted at 3 9 10 5 6

Node Depths Define excess array E[i] = rank((P,i)  rank)(P,i) depth(v) = E[v] E is not explicitly stored; it can be computed by the rank index on P (()((()())())(()())()) 1212343432321232321210 P E 2 1 3 8 4 5 6 7 9 10 11

Lowest Common Ancestor (lca) lca = lowest common ancestor u = lca(v,w): common ancestor of v and w which is furthest from root Found in O(1) time v w u

(()((()())())(()())()) 1212343432321232321210 u v m w u = parent(RMQE(v,w)+1) E is the excess array, which represents node depths m = RMQE(v,w): the index of a minimum value in E[v..w] (RMQ = Range Minimum Query) u 146 3 5 2 7 1 4 6 w 1 7 3 2 1 3 5 5 2 4 6 v P (()((()())())(()())()) 1212343432321232321210 E u v m w

DFUDS Representation [6] It encodes the degrees of nodes in unary codes in depth-first order (DFUDS = Depth First Unary Degree Sequence) Degree d ⇒ d (’s, followed by a ) Add a dummy ( at the beginning 2n bits 1 2 6 3 4 5 7 8 DFUDS U ((()((())))(())) 1 2 3 4 5 6 7 8

Proof: For n = 1, the root has no children (degree 0). Lemma: The DFUDS of an n node ordered tree forms a balanced parentheses sequence of length 2n. Proof: For n = 1, the root has no children (degree 0). Its DFUDS is (). Assume that for any tree with at most n1 nodes, the lemma holds. Let U1, U2,..., Up denote the DFUDS for p trees. (Summation of numbers of nodes is n1, total length of their DFUDS’s is 2n2) Consider a tree whose root has those trees as its children. The DFUDS U for this tree is Ui whose dummy parenthesis at the head is removed Degree of root = p Head dummy parenthesis

From the assumption of the induction, Ui is balanced. Because the head open parenthesis is removed, it lacks an open parenthesis to be balanced. The head dummy open parenthesis of U and the parentheses sequence for the root node ((p) have p open parentheses unbalanced. Therefore U is balanced. The number of nodes is n and the length of the sequence is 2n. This proves the lemma. Ui whose dummy parenthesis at the head is remove Degree of root = p Head dummy parenthesis