Data Compression Techniques

Transcription

1 Data Compression Techniques Part 3: Compressed Data Structures Lecture 11: Compressed Graphs and Trees Juha Kärkkäinen / 13

2 Compressed Graphs We will next describe a simple representation for graphs. Let G = (V, E) be a directed graph, where V = [0..n) is the set of vertices and and E V V, E = m, is the set of edges. We will use adjency lists to represent the graph. For each v V, let S v = (w V : (v, w) E) be the adjacency list for v. Let S[0..m) = S 0 S 1... S n 1 be the concatenation of the adjacency lists. Let L[0..n) be the sizes of the adjacency lists, i.e., L[v] = S v. Now each e [0..m) represents an edge (u, v): u = target(e) = access S (e) v = source(e) = search L (e) The edges incident to a node v can be listed as follows: out-edges(v) = [sum L (v), sum L (v + 1)) in-edges(v) = {select S (v, i) i [0..rank S (v, m))} 2 / 13

3 Thus the graph G is represented by: A string S[0..m) over the alphabet V = [0..n) with support for operations access, rank and select. An array L[0..n) of non-negative integers summing up to m with support for prefix sum operations sum and search. Example S = bcd c de d L = b a d c e Additional attributes such as weights can be associated to nodes using an array A[0..n) and to edges using an array B[0..m). 3 / 13

4 Let us analyze the graph representation. In uncompressed form, the string S needs m log n + o(m log n) + O(n log m) bits and the partial sum data structure needs m + n + o(m + n) bits. This is close to the size of standard adjacency lists implemented as arrays. Both S and L can be compressed, but the effectiveness of compression depends on the type of graph. For example, if node degrees vary a lot, compression may be possible. Using a wavelet tree, all graph traversal operations can be performed in O(log n) time (and some even faster). However, the time can be improved to O(log log n) using alternative data structures such as GMR and alphabet partitioning. A standard adjacency list representation supports forward traversal in constant time per step. However, backward traversal would require duplicating the data structure. The compact graph representation supports bidirectional traversal without duplication. This is a representation for general graphs. There are more efficient representations for special types of graphs such as planar graphs, and as we will see next, trees. 4 / 13

5 Balanced Parentheses Let B[0..2n) be a bitvector with n 1-bits and n 0-bits. Define excess B (i) = rank-1 B (i) rank-0 B (i) B is a balanced parentheses (BP) sequence if excess B (i) 0 for all i [0..2n]. Then each 1-bit can be interpreted as an opening parenthesis ( and each 0-bit as a closing parenthesis ). A rooted tree of n nodes can be represented as a BP sequence of 2n bits: A leaf u is represented by BP(u) = 10. An internal node v with children u 1, u 2,..., u k is represented by BP(v) = 1BP(u 1 )BP(u 2 )... BP(u k )0. Example ( ( ( ) ) ( ( ) ( ) ( ) ) ) excess ( ( () ) ( () () () ) ) 5 / 13

6 The interesting operations on BP sequences include finding the matching parenthesis and the nearest enclosing pair of parentheses. For any i, j [0..n) such that B[i] = 1 and B[j] = 0, find-close B (i) = min{j [i + 1..n) excess B (j + 1) = excess B (i)} find-open B (j) = max{i [0..j) excess B (i) = excess B (j + 1)} enclose B (i) = max{k [0..i) excess B (k) < excess B (i)} The operations can be supported in constant time using o(n) bits of space in addition to the bit vector. We omit the details but the basic techniques are similar to those used for rank and select. Rank, select and access on B are some times useful operations too. 6 / 13

7 Given a BP sequence representing a tree, a node v is represented by the position of the corresponding opening parenthesis, i.e., by the starting position of BP(v). Basic navigation operations can be implemented as follows. parent(v) = enclose B (v) first-child(v) = v + 1 next-sibling(v) = find-close B (v) + 1 (Assumes v is not a root.) In the last two operations, if the node does not exists, the return value is a position of a closing parenthesis rather than an opening parenthesis. Here are some other interesting tree operations. depth(v) = excess B (v) = 2 rank-1 B (v) v is-leaf(v) = true if access B (v + 1) = 0 is-ancestor(u, v) = true if u v < close B (u) preorder-rank(v) = rank-1 B (v) preorder-select(v) = select-1 B (v) 7 / 13

8 There are two other notable representations of rooted trees as bitvectors, DFUDS (Depth-First Unary Degree Sequence) and LOUDS (Level-Order Unary Degree Sequence). In both, a node is represented by the unary encoding of its degree. That is, a node with c children is represented by 1 c 0. Thus the length of the bitvector is 2n 1. The DFUDS representation is a concatenation of the node bitvectors in preorder (depth-first order). DFUDS supports certain operations more efficiently than BP. For example, counting the number of children of a node requires iterating trough all the children in BP but takes only constant time in DFUDS. The LOUDS representation is a concatenation of the node bitvectors in breadth-first order. It is simpler and faster than BP or DFUDS because it needs only rank and select on the bitvector. On the other hand, LOUDS does not support operations such as is-ancestor efficiently. The 2n + o(n) bits of these data structures is essentially optimal, since there are Θ(4 n /n 3/2 ) rooted trees of n nodes. 8 / 13

9 Range Minimum Queries Given an array A[0..n), a range minimum query (RMQ) asks for the smallest value in given range: For any 0 i < j n, rmq A (i, j) = min{k [i..j) A[k] A[h] for all h [i..j)} The query returns the position rather than the value. We can then obviously access the value too if needed. In case of multiple equal minima, the first one is returned. We can then find other minima with additional queries: k 1 = rmq A (i, j), k 2 = rmq A (k 1 + 1, j), k 3 = rmq A (k 2 + 1, j),... We will next describe a systematic data structure of 2n + o(n) bits that can answer RMQs in constant time. 9 / 13

10 The key to the compact RMQ data structure is that all necessary information can be encoded by a Cartesian tree. The Cartesian tree of an array A[0..n) is a rooted binary tree with n nodes representing the n positions in A. The root is represents k = rmq A (0, n). The left subtree of the root is the Cartesian tree of A[0..k) and the right subtree is the Cartesian tree of A[k + 1..n). There is no subtree for an empty range. Any Cartesian tree can be encoded with 2n bits using the balanced parentheses representation. Example Cartesian tree of A 1 and A i A 1 [i] A 2 [i] c b b a c c c a / 13

11 The first component of the data structure can answer any RMQ for a range that is completely inside a single block. Divide A into blocks of size b = (log n)/4, and encode the Cartesian tree of each block using 2b bits, requiring 2n bits in total. Build a lookup table to answer any RMQ for any such encoding. The lookup table fits in O( n log 2 n log log n) = o(n) bits. The second component can answer any RMQ for a range consisting of full blocks that is completely inside a single superblock. Let A be the sequence of length n/b consisting of the block minima. Divide A into superblocks of size b, and encode each superblock Cartesian tree using 2b bits as above. The superblock encodings need 2n/b = O(n/(log n)) = o(n) bits. The superblock encoding identifies the block with the minimum and then we can use the block encoding the find the position. The third component is a similar data structure for hyperblocks consisting of b superblocks. It fits in 2n/b 2 = O(n/(log n) 2 ) = o(n) bits. 11 / 13

12 The final component can answer any RMQ for a range consisting of full hyperblocks. Let A be the sequence of length n/b 3 consisting of the hyperblock minima. Store the answer to every RMQ on A such that the length of the range is a power of two. These minima need n/b 3 log n log n = O(n/(log n)) = o(n) bits. Any range of A can be covered by two (possibly overlapping) ranges of length power of two, and the query result is the minimum of the two covering range minima. Any range on the original array A can split into at most seven ranges whose minima can be computed by the above data structures. The final answer is the minimum of those minima. The data structure needs access to the array A for computing the minimum of the minima. Remarkably, there are a bit more complicated 2n + o(n) bit data structures that can answer RMQs in constant time without an access to A. 12 / 13

13 Summary of Compressed Data Structures We have seen how data structures with nontrivial functionality can be implemented in small additional space even when the primary data is in compressed form. We have seen how complex data structures can be built using a toolbox of basic components and techniques such as bitvectors with rank and select. This is not unlike traditional data structures but the toolbox is different. These data structures are practical: they are used in real world applications in bioinformatics and elsewhere. There are also software libraries such as SDSL (Succinct Data Structure Library). All the data structures we have seen are static: they do not support operations that modify the data. There are dynamic versions of many of the data structures, though dynamicity often comes at a cost in time and/or space. There is a new book: Gonzalo Navarro: Compact Data Structures A Practical Approach. Cambridge University Press, / 13