Advanced Data Structures - Lecture 10

Transcription

1 Advanced Data Structures - Lecture 10 Mihai Herda Succinct Data Structures We now look at the problem of representing data structures very space efficiently. A data structure is called succinct if its space occupancy is log U(n) (1 + o(1)) bits, if there are U(n) objects of size n in the universe. Note that this is already the space needed to distinguish between the objects in the universe, hence this space is asymptotically optimal in the Kolomogorov sense. Example Permutations of [1, n]: U(n) = n! lg U(n) = lg ( πn( n e )n ) = n lg n Θ(n) Hence storing permutations in length-n arrays is succinct.. Strings over = {1,..., σ} of length n: U(n) = σ n lg U(n) = n lg σ Hence storing strings as arrays of chars is succinct (assuming all char codes are being used). 3. Ordered trees of n nodes: U(n) = with Catalan number 4n n 3 π lg U(n) n Θ(lg n) Hence storing trees in a pointer-based representation is asymptotically not optimal, hence not succint. 1.1 Succinct Trees The aim is to represent a static ordered tree of n nodes using n + o(n) bits, while still being able to work with the tree as if it were stored in a pointer-based representation. In particular, we want to support the following operations, all in O(1) time: 1

2 parent(v) v next_sibling(v) parent(v): parent node of v first_child(v) first child(v): leftmost child of v next sibling(v): next sibling of v is leaf(v): test if v is a leaf is ancestor(u, v): test if u is ancestor of v subtree size(v): number of nodes below v depth(v): number of nodes on the root-to-v path Balanced Parentheses (BP) We represent the tree T as its sequence of balanced parentheses. This is obtained during a DF S through T, writing an opening parenthesis ( when a node is encountered for the first time, and a closing parenthesis ) when it is seen last. Then a node can be identified by a pair of matching parentheses (... ). We adopt the convention of identifying nodes by the position of the opening parenthesis in the BP sequence. Example. A B E F C D G K H I J BPS = ( ( ( ) ( ) ) ( ) ( ( ( ) ( ) ( ) ) ( ) ) ) A B C D E F G H I J K We can represent the BPS in a bit-string B of length n by encoding ( as 1 and ) as 0. Let us define the excess of a position 1 i in B as the number of ( s minus the number of ) s in the prefix of B up to position i: Definition 1. excess(b, i) = {j i : B[j] = ( } {j i : B[j] = ) }

3 Note that the excess is never negative and it is equal to 0 only for the last position i = n. Example B = ( ( ( ) ( ) ) ( ) ( ( ( ) ( ) ( ) ) ( ) ) ) }excess 1.1. Reduction to Core Operations The navigational operations can be reduced to the following 4 core operations: rank ( (B, i) = number of ( s in B[0, i] rank ) (B, i) = number of ) s in B[0, i] findclose(b, i) = position of matching closing parenthesis if B[i] = ( enclose(b, i) = position j of the opening parenthesis such that (j, f indclose(j)) encloses (i, f indclose(i)) most tightly. Example B = ( ( ( ) ( ) ) ( ) ( ( ( ) ( ) ( ) ) ( ) ) ) enclose(15) = 10 The operations can be expressed as follows: parent(i) = enclose(b, i) (if i 0, otherwise root) first child(i) = i + 1 (if B[i] = (, otherwise leaf) next sibling(i) = findclose(i) + 1 (if B[findclose(i) + 1] = (, otherwise i is last sibling) is leaf(i) = true iff B[i + 1] = ) is ancestor(i, j) = true iff i j findclose(b, i) subtree size(i) = (findclose(i) i + 1)/ depth(i) = rank ( (B, i) rank ) (B, i) Note also excess(i) = rank ( (B, i) rank ) (B, i) for all positions i (not only for positions of opening parantheses, where excess(i) = depth(i)). In order to jump directly to the opening parenthesis of the i th node, we define the operation select as follows: Definition. select ( (B, i) = position of i th ( in B 3

4 1. Rank and Select We start with rank and select, as they will also be used as subroutines for findclose and enclose. Recall that we represent the BPS as a bit-vector, hence we can formulate the following task: given: a bit-vector B of length n compute: a data structure that supports rank 1 (B, i) and select 1 (B, i) for all i j n. The size of the data structure should be asymptotically smaller than the size of B. For rank, we divide B into blocks of length s = lg n and superblocks of length s = s. In a table SBlkRank[0, n/s ], we store the answers to rank for super-blocks, and in BlkRank[0, n/s] the same for blocks, but only relative to the beginning of the super-block: SBlkRank[i] = rank 1 (B, i s 1) BlkRank[i] = rank 1 (B, i s 1) rank 1 (B, i s s 1) Example B = }} s s' SBlkRank = BlkRank = Inblock = i = pattern We also store a lookup table Inblock[0, s 1][0, s 1] where inblock[pattern][i] = rank 1 (pattern, i) for all bit patterns of length s and all 0 i s. Then rank 1 (B, i) = SBlkRank[ i s ] + BlkRank[ i s ] + Inblock[B[, i + 1 ]][i i s s] The sizes of the data structures are order of SBlkRank = BlkRank = n s lg s = n s lg n = n lg n, #bits for value #superblocks n lg lg n lg n, and Inblock = s s lg s = n lg n lg lg n, all o(n) bits. i s s start of i s block s s 1 end of i s block 4

5 1.3 Recommended Reading R.F.Geary, N.Rahman, R. Raman, V.Raman: A Simple Optimal Representation for Balanced Parantheses. Theor. Comp. Sci. 368(3): 31-46, 006. J. I. Munro, V. Raman: Succinct Representation of Balanced Parenthesis and Static Trees. SIAM J. Comput 31(3): , 001. There is a vast amount of literature on succinct tree representations, focusing on enhancing the set of supported operations( i-th child, lca, level-ancestor,... ), dynamization(insert/delete nodes), lowering the redundancy(the o(n)-term), etc. A good pointer to recent developments is: K. Sadakane, G. Navarro: Fully-Functional Succinct Trees. Proc. SODA: ,