|
|
| Line 1: |
Line 1: |
| In [[computer science]], a '''succinct data structure''' is a [[data structure]] which uses an amount of space that is "close" to the [[information-theoretic]] lower bound, but (unlike other compressed representations) still allows for efficient query operations. The concept was originally introduced by Jacobson <ref name="jacobson1988succinct"/> to encode [[bit vector]]s, (unlabeled) [[tree (data structure)|trees]], and [[planar graph]]s. Unlike general [[lossless data compression]] algorithms, succinct data structures retain the ability to use them in-place, without decompressing them first. A related notion is that of a [[compressed data structure]], in which the size of the data structure depends upon the particular data being represented.
| | Emilia Shryock is my title but you can call me something you like. Hiring is her day job now but she's always needed her own business. Her family lives in Minnesota. The favorite pastime for my children and me is to play baseball and I'm trying to make it a occupation.<br><br>Feel free to surf to my web page :: [http://www.gaysphere.net/user/Z5147 www.gaysphere.net] |
| | |
| Suppose that <math>Z</math> is the information-theoretical optimal number of bits needed to store some data. A representation of this data is called
| |
| | |
| * ''[[implicit data structure|implicit]]'' if it takes <math>Z + O(1)</math> bits of space,
| |
| * ''succinct'' if it takes <math>Z + o(Z)</math> bits of space, and
| |
| * ''compact'' if it takes <math>O(Z)</math> bits of space.
| |
| | |
| Implicit structures are thus usually reduced to storing information using some permutation of the input data; the most well-known example of this is the heap.
| |
| | |
| ==Succinct dictionaries==
| |
| | |
| Succinct indexable dictionaries, also called ''rank/select'' dictionaries, form the basis of a number of succinct representation techniques, including [[binary trees]], <math>k</math>-ary trees and [[multisets]],<ref name="raman2002succinct"/> as well as [[suffix tree]]s and [[suffix array|arrays]].<ref name="sadakane2006squeezing"/> The basic problem is to store a subset <math>S</math> of a universe <math>U =
| |
| [0 \dots n) = \{0, 1, \dots, n - 1\}</math>, usually represented as a bit array <math>B[0 \dots n)</math> where <math>B[i] = 1</math> iff <math>i \in S</math>. An indexable dictionary supports the usual methods on dictionaries (queries, and insertions/deletions in the dynamic case) as well as the following operations:
| |
| | |
| * <math>\mathbf{rank}_q(x) = |\{ k \in [0 \dots x) : B[k] = q \}|</math>
| |
| * <math>\mathbf{select}_q(x)= \min \{k \in [0 \dots n) : \mathbf{rank}_q(k) = x\}</math>
| |
| | |
| for <math>q \in \{0, 1\}</math>.
| |
| | |
| In other words, <math>\mathbf{rank}_q(x)</math> returns the number of elements equal to <math>q</math> up to position <math>x</math> while <math>\mathbf{select}_q(x)</math> returns the position of the <math> x</math>-th occurrence of <math> q </math>.
| |
| | |
| There is a simple representation <ref name="jacobson1989space"/> which uses <math>n + o(n)</math> bits of storage space (the original bit array and an <math>o(n)</math> auxiliary structure) and supports '''rank''' and '''select''' in constant time. It uses an idea similar to that for [[Range Minimum Query|range-minimum queries]]; there are a constant number of recursions before stopping at a subproblem of a limited size. The bit array <math>B</math> is partitioned into ''large blocks'' of size <math>l = \lg^2 n</math> bits and ''small blocks'' of size <math>s = \lg n / 2</math> bits. For each large block, the rank of its first bit is stored in a separate table <math>R_l[0 \dots n/l)</math>; each such entry takes <math>\lg n</math> bits for a total of <math>(n/l) \lg n = n / \lg n</math> bits of storage. Within a large block, another directory <math>R_s[0 \dots l/s)</math> stores the rank of each of the <math>l/s = 2 \lg n</math> small blocks it contains. The difference here is that it only needs <math>\lg l = \lg \lg^2 n = 2 \lg \lg n</math> bits for each entry, since only the differences from the rank of the first bit in the containing large block need to be stored. Thus, this table takes a total of <math>(n/s) \lg l = 4 n \lg \lg n / \lg n</math> bits. A lookup table <math>R_p</math> can then be used that stores the answer to every possible rank query on a bit string of length <math>s</math> for <math>i \in [0, s)</math>; this requires <math>2^s s \lg s = O(\sqrt{n} \lg n \lg \lg n)</math> bits of storage space. Thus, since each of these auxiliary tables take <math>o(n)</math> space, this data structure supports rank queries in <math>O(1)</math> time and <math>n + o(n)</math> bits of space.
| |
| | |
| To answer a query for <math>\mathbf{rank}_1(x)</math> in constant time, a constant time algorithm computes
| |
| | |
| <math>\mathbf{rank}_1(x) = R_l[\lfloor x / l \rfloor] + R_s[\lfloor x / s\rfloor] + R_p[x \lfloor x / s\rfloor, x \text{ mod } s]</math>
| |
| | |
| In practice, the lookup table <math>R_p</math> can be replaced by bitwise operations and smaller tables to perform find the number of bits set in the small blocks. This is often beneficial, since succinct data structures find their uses in large data sets, in which case cache misses become much more frequent and the chances of the lookup table being evicted from closer CPU caches becomes higher.<ref name="gonzález2005practical" /> Select queries can be easily supported by doing a binary search on the same auxiliary structure used for '''rank'''; however, this takes <math>O(\lg n)</math> time in the worst case. A more complicated structure using <math>3n/\lg \lg n + O(\sqrt{n} \lg n \lg \lg n) = o(n)</math> bits of additional storage can be used to support '''select''' in constant time.<ref name="clark1998compact" /> In practice, many of these solutions have hidden constants in the <math>O(\cdot)</math> notation which dominate before any asymptotic advantage becomes apparent; implementations using broadword operations and word-aligned blocks often perform better in practice.<ref name="vigna2008broadword" />
| |
| | |
| ===Entropy-compressed dictionaries===
| |
| | |
| The <math>n + o(n)</math> space approach can be improved by noting that there are <math>\textstyle \binom{n}{m}</math> distinct <math>m</math>-subsets of <math>[n)</math> (or binary strings of length <math>n</math> with exactly <math>m</math> 1’s), and thus <math>\textstyle \mathcal{B}(m,n) = \lceil \lg \binom{n}{m} \rceil</math> is an information theoretic lower bound on the number of bits needed to store <math>B</math>. There is a succinct (static) dictionary which attains this bound, namely using <math>\mathcal{B}(m,n) + o(\mathcal{B}(m,n))</math> space.<ref name="brodnik1999membership" /> This structure can be extended to support '''rank''' and '''select''' queries and takes <math>\mathcal{B}(m,n) + O(m + n \lg \lg n / \lg n)</math> space.<ref name="raman2002succinct" /> This bound can be reduced to a space/time tradeoff by reducing the storage space of the dictionary to <math>\mathcal{B}(m,n) + O(n t^t / \lg^t n + n^{3/4})</math> with queries taking <math>O(t)</math> time.<ref name="patrascu2008succincter" />
| |
| | |
| ==Examples==
| |
| | |
| When a sequence of variable-length items needs to be encoded, the items can simply be placed one after another, with no delimiters. A separate binary string consisting of 1s in the positions where an item begins, and 0s every where else is encoded along with it. Given this string, the <math>select</math> function can quickly determine where each item begins, given its index.<ref>{{cite web|url=http://cmph.sourceforge.net/papers/esa09.pdf |title=Hash, displace, and compress|last=Belazzougui|first=Djamal}}</ref>
| |
| | |
| Another example is the representation of a [[binary tree]]: an arbitrary binary tree on <math>n</math> nodes can be represented in <math>2n + o(n)</math> bits while supporting a variety of operations on any node, which includes finding its parent, its left and right child, and returning the size of its subtree, each in constant time. The number of different binary trees on <math>n</math> nodes is <math>{\tbinom{2n}{n}}</math><math>/(n+1)</math>. For large <math>n</math>, this is about <math>4^n</math>; thus we need at least about <math>\log_2(4^n)=2n</math> bits to encode it. A succinct binary tree therefore would occupy only <math>2</math> bits per node.
| |
| | |
| ==References==
| |
| <references>
| |
| <ref name="jacobson1988succinct">
| |
| {{Cite journal
| |
| | last = Jacobson
| |
| | first = G. J
| |
| | title = Succinct static data structures
| |
| | year = 1988
| |
| }}
| |
| </ref>
| |
| <ref name="raman2002succinct">
| |
| {{Cite conference
| |
| | isbn = 0-89871-513-X
| |
| | pages = 233–242
| |
| | last = Raman
| |
| | first = R.
| |
| | coauthors = V. Raman, S. S Rao
| |
| | title = Succinct indexable dictionaries with applications to encoding k-ary trees and multisets
| |
| | booktitle = Proceedings of the thirteenth annual ACM-SIAM symposium on Discrete algorithms
| |
| | date = 2002
| |
| | url = http://www.cs.cmu.edu/afs/cs.cmu.edu/project/aladdin/wwwlocal/hash/RaRaRa02.pdf
| |
| }}
| |
| </ref>
| |
| <ref name="sadakane2006squeezing">
| |
| {{Cite conference
| |
| | isbn = 0-89871-605-5
| |
| | pages = 1230–1239
| |
| | last = Sadakane
| |
| | first = K.
| |
| | coauthors = R. Grossi
| |
| | title = Squeezing succinct data structures into entropy bounds
| |
| | booktitle = Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm
| |
| | date = 2006
| |
| | url = http://www.dmi.unisa.it/people/cerulli/www/WSPages/WSFiles/Abs/S3/S33_abs_Grossi.pdf
| |
| }}
| |
| </ref>
| |
| <ref name="jacobson1989space">
| |
| {{Cite journal
| |
| | last = Jacobson
| |
| | first = G.
| |
| | title = Space-efficient static trees and graphs
| |
| | year = 1989
| |
| | url = http://www.cs.cmu.edu/afs/cs/project/aladdin/wwwlocal/compression/00063533.pdf
| |
| }}
| |
| </ref>
| |
| <ref name="gonzález2005practical">
| |
| {{Cite conference
| |
| | pages = 27–38
| |
| | last = González
| |
| | first = R.
| |
| | coauthors = S. Grabowski, V. Mäkinen, G. Navarro
| |
| | title = Practical implementation of rank and select queries
| |
| | booktitle = Poster Proceedings Volume of 4th Workshop on Efficient and Experimental Algorithms (WEA)
| |
| | date = 2005
| |
| | url = http://www.dcc.uchile.cl/~gnavarro/algoritmos/ps/wea05.pdf
| |
| }}
| |
| </ref>
| |
| <ref name="clark1998compact">
| |
| {{Cite journal
| |
| | last = Clark
| |
| | first = D.
| |
| | title = Compact pat trees
| |
| | year = 1998
| |
| | url = https://uwspace.uwaterloo.ca/bitstream/10012/64/1/nq21335.pdf
| |
| }}
| |
| </ref>
| |
| <ref name="vigna2008broadword">
| |
| {{Cite journal
| |
| | pages = 154–168
| |
| | last = Vigna
| |
| | first = S.
| |
| | title = Broadword implementation of rank/select queries
| |
| | journal = Experimental Algorithms
| |
| | year = 2008
| |
| | url = http://sux.dsi.unimi.it/paper.pdf
| |
| | doi = 10.1007/978-3-540-68552-4_12
| |
| | series = Lecture Notes in Computer Science
| |
| | isbn = 978-3-540-68548-7
| |
| | volume = 5038
| |
| }}
| |
| </ref>
| |
| <ref name="brodnik1999membership">
| |
| {{Cite journal
| |
| | volume = 28
| |
| | issue = 5
| |
| | pages = 1627–1640
| |
| | last = Brodnik
| |
| | first = A.
| |
| | coauthors = J. I Munro
| |
| | title = Membership in constant time and almost-minimum space
| |
| | journal = SIAM J. Comput.
| |
| | year = 1999
| |
| | url = http://www.cs.cmu.edu/afs/cs.cmu.edu/project/aladdin/wwwlocal/compression/BM99.pdf
| |
| | doi = 10.1137/S0097539795294165
| |
| }}
| |
| </ref>
| |
| <ref name="patrascu2008succincter">
| |
| {{Cite conference
| |
| | pages = 305–313
| |
| | last = Pătraşcu
| |
| | first = M. | authorlink = Mihai Pătraşcu
| |
| | title = Succincter
| |
| | booktitle = Foundations of Computer Science, 2008. FOCS'08. IEEE 49th Annual IEEE Symposium on
| |
| | date = 2008
| |
| | url = http://people.csail.mit.edu/mip/papers/succinct/succinct.pdf
| |
| }}
| |
| </ref>
| |
| </references>
| |
| | |
| {{DEFAULTSORT:Succinct Data Structure}}
| |
| [[Category:Data structures]]
| |
Emilia Shryock is my title but you can call me something you like. Hiring is her day job now but she's always needed her own business. Her family lives in Minnesota. The favorite pastime for my children and me is to play baseball and I'm trying to make it a occupation.
Feel free to surf to my web page :: www.gaysphere.net