Download presentation

Presentation is loading. Please wait.

Published byColton Sinkey Modified over 3 years ago

1
Succinct Representations of Dynamic Strings Meng He and J. Ian Munro University of Waterloo

2
Background: Succinct Data Structures What are succinct data structures (Jacobson 1989) Representing data structures using ideally information-theoretic minimum space Supporting efficient navigational operations Why succinct data structures Large data sets in modern applications: textual, genomic, spatial or geometric

3
Strings: Definitions Notation Alphabet: [σ]={1, 2, …, σ} String: S[1..n] Operations: access(i): S[i] rank( α, i): number of occurrences of α in S[1..i] select( α, i): position of the i th occurrence of α in S

4
Strings: An Example S = a a b a c c c d a d d a b b b c string_access(8) =d string_rank(a, 8) =3 string_select(b, 3) =14

5
Succinct Representations of Strings Information-theoretic minimum: n lg σ bits Succinct representation (Grossi et al. 2003) Space: n H 0 +o(n)∙lg σ bits Time: O(lg σ) There are many more results. The case in which σ = 2 (bit vector) is even more fundamental! Jacobson 1989

6
Applications of Strings and Bit Vectors Ordinal trees on n nodes Standard approach: 3n lg n bits Succinct data structures: 2n + o(n) bits (Jacobson 1989, Munro & Raman 1997, Benoit et al. 1999…) Full text indexes for text string from [σ] n Suffix trees can use as much as 4n lg n to 6n lg n bits! Succinct data structures: n lg σ +o(n lg σ) bits ( Grossi et al. 2003, González and Navarro 2009… ) Labeled trees, planar graphs, binary relations, permutations, functions, …

7
Our Problem: Dynamic Strings Motivation: In many applications, data are also updated frequently For strings, we also consider the following update operations: insert( α, i), which inserts character α between S[i-1] and S[i] delete(i), which deletes S[i] from S

8
Comparisons Space (bits)Access, rank and select Insert and delete Gupta et al. 2007 n lg σ +lg σ∙(o(n)+O(1)) O(lg lg n)O(n ε ) amortized Mäkinen & Navarro 2008 n H 0 +o(n)∙lg σO(lg n lg σ) Lee & Park 2009 n lg σ +o(n)∙lg σ González and Navarro 2009 n H 0 +o(n)∙lg σ This papern H 0 +o(n)∙lg σ O(lg n ( ──── + 1)) lg σ lg lg n O(lg n ( ──── + 1)) lg σ lg lg n amortized O(lg n ( ──── + 1)) lg σ lg lg n O(lg n ( ──── + 1)) lg σ lg lg n O(──── ( ──── + 1)) lg σ lg lg n lg n lg lg n O(──── ( ──── + 1)) lg σ lg lg n lg n lg lg n For the special cases in which σ = polylog (n) or 2 (bit vector!), our results also improve previous results

9
Searchable Partial Sums Data A sequence Q of n nonnegative integers Operations sum(i): Q[1] + Q[2] + … + Q[i] search(x): the smallest i such that sum(i) ≥ x update(i, δ): Q[i] ← Q[i] + δ Raman et al. 2001 Assumptions: |Q| = O(lg ε n), |δ| ≤ lg n Space: O(lg 1+ε n) bits, with a universal table of size O(n ε’ ) bits Operations: O(1) time

10
Collections of Searchable Partial Sums Data d sequences of k-bit nonnegative integers of length n each Operations sum, search, update: supported on each sequence insert, delete: operated simultaneously on the same positions of all the sequences, but only 0’s can be inserted or deleted González and Navarro 2009 (CSPSI) 8 2 9 5 11 9 0 7 3 6 1 5 3 12 4 5 12 0 3 1 19 0 4 2 8 3 5 4 1 0 000000 sum(2, 5) =25insert(6)delete(6)

11
Our results on CSPSI Assumptions d = O(lg η n) |δ| ≤ lg n Space O(kdn + w) bits, where w is the word size Buffer: O(n lg n) bits Time All operations: O ( ──── ) lg n lg lg n

12
Data Structures for Dynamic Strings Over a Small Alphabet of size O(lg 1/2 n) Main data structure: a B-tree constructed over S Leaf Each leaf stores a superblock of at most 2L bits which encodes a substring of S (L = ) The numbers of occurrences of each character in all the superblocks form an integer sequence Maintain the above sequences for all the characters in the alphabet in a CSPSI structure E Internal node v (lg 1/2 n ≤ degree(v) ≤ 2lg 1/2 n) U(v): U(v)[i] = number of leaves of the subtree rooted at the i-th child of v I(v): I(v)[i] = number of characters stored in the subtree rooted at the i-th child of v ──── lg 2 n lg lg n

13
Supporting Queries rank( α, i) Perform a top-down traversal with the help of I(v)’s Locate the superblock, j, containing S[i] with the help of U(v)’s Perform sum( α, j) operation on E to count the number of occurrences of α in superblocks 1, 2, … j-1 Read superblock j in blocks of size (lg n) / 2 bits The support for access and select is similar v ……

14
Insert, delete and deamortization Supporting insert and delete requires traversing and updating the B-tree and updating E It is however much more complicated Merging and splitting B-tree nodes Deamortization

15
Succinct Global Rebuilding A key technique for deamortizing operations on B-trees is global rebuilding (Overmars and van Leeuwen 1981) Global rebuilding Rebuild the B-tree after the number of update operations performed exceeds half the initial length of the string A new copy and an old copy of the B-tree: more space A buffer of O(n lg n) bits is required Succinct global rebuilding Only one copy of the data: no duplication During rebuilding, queries and updates are performed on either the new part or the old part No buffer required

16
Putting Everything Together Dynamic strings over an alphabet of size O(lg 1/2 n) Space: n H 0 +o(n)∙lg σ bits Time: This can be extended to general alphabets using wavelet trees Space: n H 0 +o(n)∙lg σ bits Time: When σ = polylog (n) or 2 (bit vectors) Space: n H 0 +o(n)∙lg σ bits Time: O ( ──── ) lg n lg lg n O(──── ( ──── + 1)) lg σ lg lg n lg n lg lg n O ( ──── ) lg n lg lg n

17
Applications Dynamic text collections Data: a collection of text strings Operations Pattern search Display a substring Insert/delete a text string Compressed construction of full-text indexes Working space: n H k +o(n)∙lg σ bits Time: O(──── ( ──── + 1)) lg σ lg lg n n lg n lg lg n

18
Conclusions We designed a succinct representation of dynamic strings that provide more efficient operations than previous results This structure can be directly applied to improve previous results on text indexing We expect our results to play an important role in the design of dynamic succinct data structures We expect succinct global rebuilding to be useful for the deamotization of algorithms on dynamic succinct data structures

19
Thank you!

Similar presentations

OK

Succinct Data Structures Ian Munro University of Waterloo Joint work with David Benoit, Andrej Brodnik, D, Clark, F. Fich, M. He, J. Horton, A. López-Ortiz,

Succinct Data Structures Ian Munro University of Waterloo Joint work with David Benoit, Andrej Brodnik, D, Clark, F. Fich, M. He, J. Horton, A. López-Ortiz,

© 2019 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google