We consider the well-studied partial sums problem in succint space where one
is to maintain an array of n k-bit integers subject to updates such that
partial sums queries can be efficiently answered. We present two succint
versions of the Fenwick Tree - which is known for its simplicity and
practicality. Our results hold in the encoding model where one is allowed to
reuse the space from the input data. Our main result is the first that only
requires nk + o(n) bits of space while still supporting sum/update in O(log_b
n) / O(b log_b n) time where 2 <= b <= log^O(1) n. The second result shows how
optimal time for sum/update can be achieved while only slightly increasing the
space usage to nk + o(nk) bits. Beyond Fenwick Trees, the results are primarily
based on bit-packing and sampling - making them very practical - and they also
allow for simple optimal parallelization

AC Yao

M Patrascu

ML Fredman

PF Dietz

PM Fenwick

R Raman

T Hagerup

WK Hon

English

arXiv

We consider the well-studied partial sums problem in succint space where one is to maintain an array of n k-bit integers subject to updates such that partial sums queries can be efficiently answered. We present two succint versions of the Fenwick Tree – which is known for its simplicity and practicality. Our results hold in the encoding model where one is allowed to reuse the space from the input data. Our main result is the first that only requires nk + o(n) bits of space while still supporting sum/update in O(logbn)/O(blogbn) time where 2 ≤ b ≤ log O(1)n. The second result shows how optimal time for sum/update can be achieved while only slightly increasing the space usage to nk + o(nk) bits. Beyond Fenwick Trees, the results are primarily based on bit-packing and sampling – making them very practical – and they also allow for simple optimal parallelization

Bille P.

Christiansen A. R.

Prezza N.

Skjoldjensen F. R.

Archivio istituzionale della ricerca - Università degli Studi di Venezia Ca' Foscari

Succinct partial sums and fenwick trees

Philip Bille

Anders Roy Christiansen

Nicola Prezza

Frederik Rye Skjoldjensen

Crossref

Succinct Partial Sums and Fenwick Trees

We consider the well-studied partial sums problem in succint space where one is to maintain an array of n k-bit integers subject to updates such that partial sums queries can be efficiently answered. We present two succint versions of the Fenwick Tree â€“ which is known for its simplicity and practicality. Our results hold in the encoding model where one is allowed to reuse the space from the input data. Our main result is the first that only requires nk + o(n) bits of space while still supporting sum/update in O(logbn)/O(blogbn) time where 2 â‰¤ b â‰¤ log O(1)n. The second result shows how optimal time for sum/update can be achieved while only slightly increasing the space usage to nk + o(nk) bits. Beyond Fenwick Trees, the results are primarily based on bit-packing and sampling â€“ making them very practical â€“ and they also allow for simple optimal parallelization

Bille, Philip

Christiansen, Anders Roy

Prezza, Nicola

Skjoldjensen, Frederik Rye

Online Research Database In Technology

  General rights Copyright and moral rights for the publications made accessible in the public portal are retained by the authors and/or other copyright owners and it is a condition of accessing publications that users recognise and abide by the legal requirements associated with these rights.   Users may download and print one copy of any publication from the public portal for the purpose of private study or research.  You may not further distribute the material or use it for any profit-making activity or commercial gain  You may freely distribute the URL identifying the publication in the public portal  If you believe that this document breaches copyright please contact us providing details, and we will remove access to the work immediately and investigate your claim.         Downloaded from orbit.dtu.dk on: Mar 28, 2019Succinct partial sums and fenwick treesBille, Philip; Christiansen, Anders Roy; Prezza, Nicola; Skjoldjensen, Frederik RyePublished in:String Processing and Information RetrievalLink to article, DOI:10.1007/978-3-319-67428-5_8Publication date:2017Document VersionEarly version, also known as pre-printLink back to DTU OrbitCitation (APA):Bille, P., Christiansen, A. R., Prezza, N., & Skjoldjensen, F. R. (2017). Succinct partial sums and fenwick trees.In String Processing and Information Retrieval (pp. 91-96). Springer.  Lecture Notes in Computer Science, Vol..10508, DOI: 10.1007/978-3-319-67428-5_8Succinct Partial Sums and Fenwick TreesPhilip Bille, Anders Roy Christiansen, Nicola Prezza, and Frederik RyeSkjoldjensenTechnical University of Denmark, DTU Compute, Kgs. Lyngby, Denmark{phbi,aroy,npre,fskj}@dtu.dkAbstract. We consider the well-studied partial sums problem in succintspace where one is to maintain an array of n k-bit integers subject toupdates such that partial sums queries can be efficiently answered. Wepresent two succint versions of the Fenwick Tree – which is known forits simplicity and practicality. Our results hold in the encoding modelwhere one is allowed to reuse the space from the input data. Our mainresult is the first that only requires nk + o(n) bits of space while stillsupporting sum/update in O(logb n) / O(b logb n) time where 2 ≤ b ≤logO(1) n. The second result shows how optimal time for sum/updatecan be achieved while only slightly increasing the space usage to nk +o(nk) bits. Beyond Fenwick Trees, the results are primarily based onbit-packing and sampling – making them very practical – and they alsoallow for simple optimal parallelization.Keywords: Partial sums, Fenwick tree, succinct, parallel1 IntroductionLet A be an array of k-bits integers, with |A| = n. The partial sums problem isto build a data structure maintaining A under the following operations.– sum(i): return the value∑it=1A[t].– search(j): return the smallest i such that sum(i) ≥ j.– update(i,∆): set A[i]← A[i] +∆, for some ∆ such that 0 ≤ A[i] +∆ < 2k.– access(i): return A[i].Note that access(i) can implemented as sum(i)−sum(i − 1) and we thereforeoften do not mention it explicitly.The partial sums problem is one the most well-studied data structure prob-lems [1, 2, 3, 4, 6, 7, 8, 9]. In this paper, we consider solutions to the partial sumsproblem that are succinct, that is, we are interested in data structures thatuse space close to the information-theoretic lower bound of nk bits. We distin-guish between encoding data structures and indexing data structures. Indexingdata structures are required to store the input array A verbatim along with ad-ditional information to support the queries, whereas encoding data structureshave to support operations without consulting the input array.arXiv:1705.10987v1  [cs.DS]  31 May 2017In the indexing model Raman et al. [8] gave a data structure that supportssum, update, and search in O(log n/ log log n) time while using nk+o(nk) bits ofspace. This was improved and generalized by Hon et al. [6]. Both of these papershave the constrain ∆ ≤ logO(1) n. The above time complexity is nearly optimalby a lower bound of Patrascu and Demaine [7] who showed that sum, search,and update operations takes Θ(logw/δ n) time per operation, where w ≥ log n isthe word size and δ is the number of bits needed to represent ∆. In particular,whenever ∆ = logO(1) n this bound matches the O(log n/ log log n) bound ofRaman et al. [8].Fenwick [2] presented a simple, elegant, and very practical encoding datastructure. The idea is to replace entries in the input array A with partial sumsthat cover A in an implicit complete binary tree structure. The operations arethen implemented by accessing at most log n entries in the array. The Fenwicktree uses nk + n log n bits and supports all operations in O(log n) time. In thispaper we show two succinct b-ary versions of the Fenwick tree. In the first versionwe reduce the size of the Fenwick tree while improving the sum and update time.In the second version we obtain optimal times for sum and update without usingmore space than the previous best succinct solutions [6, 8]. All results in thispaper are in the RAM model.Our results We show two encoding data structures that gives the following re-sults.Theorem 1. We can replace A with a succinct Fenwick tree of nk + o(n) bitssupporting sum, update, and search queries in O(logb n), O(b logb n), and O(log n)time, respectively, for any 2 ≤ b ≤ logO(1) n.Theorem 2. We can replace A with a succinct Fenwick tree of nk + o(nk) bitssupporting sum and update queries in optimal O(logw/δ n) time and searchqueries in O(log n) time.2 Data structureFor simplicity, assume that n is a power of 2. The Fenwick tree is an implicitdata structure replacing a word-array A[1, . . . , n] as follows:Definition 1. Fenwick tree of A [2]. If n = 1, then leave A unchanged. Oth-erwise, divide A in consecutive non-overlapping blocks of two elements eachand replace the second element A[2i] of each block with A[2i − 1] + A[2i], fori = 1, . . . , n/2. Then, recurse on the sub-array A[2, 4, . . . , 2i, . . . , n].To answer sum(i), the idea is to write i in binary as i = 2j1 + 2j2 + · · ·+ 2jkfor some j1 > j2 > · · · > jk. Then there are k ≤ log n entries in the Fenwicktree, that can be easily computed from i, whose values added together yieldsum(i). In Section 2.1 we describe in detail how to perform such accesses. Asper the above definition, the Fenwick tree is an array of n indices. If representedcompactly, this array can be stored in nk+n log n bits. In this section we presenta generalization of Fenwick trees taking only succinct space.2.1 Layered b-ary structureWe first observe that it is easy to generalize Fenwick trees to be b-ary, for b ≥ 2:we divide A in blocks of b integers each, replace the first b− 1 elements in eachblock with their partial sum, and fill the remaining n/b entries of A by recursingon the array A′ of size n/b that stores the sums of each block. This generalizationgives an array of n indices supporting sum, update, and search queries on theoriginal array in O(logb n), O(b logb n), and O(log n) time, respectively. We nowshow how to reduce the space of this array.Let ` = logb n. We represent our b-ary Fenwick tree Tb(A) using `+ 1 arrays(layers) T 1b (A), . . . , T`+1b (A). For simplicity, we assume that n = be for somee ≥ 0 (the general case is then straightforward to derive). To improve readability,we define our layered structure for the special case b = 2, and then sketch howto extend it to the general case b ≥ 2. Our layered structure is defined as follows.If n = 1, then T 12 (A) = A. Otherwise:– T `+12 (A)[i] = A[(i − 1) · 2 + 1], for all i = 1, . . . , n/2. Note that T `+12 (A)contains n/2 elements.– Divide A in blocks of 2 elements each, and build an array A′[j] containingthe n/2 sums of each block, i.e. A′[j] = A[(j − 1) · 2 + 1] +A[(j − 1) · 2 + 2],for j = 1, . . . , n/2. Then, the next layers are recursively defined as T `2 (A)←T `2 (A′), . . . , T 12 (A)← T 12 (A′).For general b ≥ 2, T `+1b (A) is an array of n(b−1)b elements that stores theb − 1 partial sums of each block of b consecutive elements in A, while A′ is anarray of size n/b containing the complete sums of each block. In Figure 1 wereport an example of our layered structure with b = 3. It follows that elementsof T ib (A), for i > 1, take at most k + (` − i + 2) log b bits each. Note thatarrays T 1b (A), . . . , T`+1b (A) can easily be packed contiguously in a word arraywhile preserving constant-time access to each of them. This saves us O(`) wordsthat would otherwise be needed to store pointers to the arrays. Let Sb(n, k) bethe space (in bits) taken by our layered structure. This function satisfies therecurrenceSb(1, k) = kSb(n, k) =n(b−1)b · (k + log b) + Sb(n/b, k + log b)Which unfolds to Sb(n, k) =∑logb n+1i=1n(b−1)bi · (k + i log b) . Using the identities∑∞i=1 1/bi = 1/(b − 1) and ∑∞i=1 i/bi = b/(b − 1)2, one can easily derive thatSb(n, k) ≤ nk + 2n log b.We now show how to obtain the time bounds stated in Theorem 1. In thenext section, we reduce the space of the structure without affecting query times.Answering sum Let the notation (x1x2 . . . xt)b, with 0 ≤ xi < b for i = 1, . . . , t,represent the number∑ti=1 bt−ixi in base b. sum(i) queries on our structureare a generalization (in base b) of sum(i) queries on standard Fenwick trees.Consider the base-b representation x1x2 . . . x`+1 of i, i.e. i = (x1x2 . . . x`+1)b(note that we have at most `+1 digits since we enumerate indexes starting from1). Consider now all the positions 1 ≤ i1 < i2 < · · · < it ≤ `+1 such that xj 6= 0,for j = i1, . . . , it. The idea is that each of these positions j = i1, . . . , it can beused to compute an offset oj in Tjb (A). Then, sum(i) =∑j=i1,...,itT jb (A)[oj ].The offset oj relative to the j-th most significant (nonzero) digit of i is defined asfollows. If j = 1, then oj = x1. Otherwise, oj = (b− 1) · (x1 . . . xj−1)b + xj . Notethat we scale by a factor of b − 1 (and not b) as the first term in this formulaas each level T j(A) stores only b− 1 out of b partial sums (the remaining sumsare passed to level j− 1). Note moreover that each oj can be easily computed inconstant time and independently from the other offsets with the aid of modulararithmetic. It follows that sum queries are answered in O(logb n) time. See Figure1 for a concrete example of sum.Answering update The idea for performing update(i,∆) is analogous to that ofsum(i). We access all levels that contain a partial sum covering position i andupdate at most b− 1 sums per level. Using the same notation as above, for eachj = i1, . . . , it such that xj 6= 0, we update T jb (A)[oj + l]← T jb (A)[oj + l] +∆ forl = 0, . . . , b− xj − 1. This procedure takes O(b logb n) time.Answering search To answer search(j) we start from T 1b (A) and simply performa top-down traversal of the implicit B-tree of degree b defined by the layeredstructure. At each level, we perform O(log b) steps of binary search to find thenew offset in the next level. There are logb n levels, so search takes overallO(log n) time.7 15 2 5 5 12 5 6 3 10 9 19 3 5 3 8 2 47 8 3 2 3 1 5 7 3 5 1 0 3 7 4 9 10 11 3 2 1 3 5 4 2 2 41 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 2718 24 6 20 6 1839 89115Fig. 1. Example of our layered structure with n = 27 and b = 3. Horizontal red linesshow the portion of A covered by each element in T j3 (A), for j = 1, . . . , logb n + 1. Toaccess the i-th partial sum, we proceed as follows. Let, for example, i = 19 = (0201)3.The only nonzero digits in i are the 2-nd and 4-th most significant. This gives uso2 = 2 · (0)3 + 2 = 2 and o4 = 2 · (020)3 + 1 = 13. Then, sum(19) = T 23 (A)[2] +T 43 (A)[13] = 89 + 3 = 92.2.2 SamplingLet 0 < d ≤ n be a sample rate, where for simplicity we assume that d divides n.Given our input array A, we derive an array A′ of n/d elements containing thesums of groups of d adjacent elements in A, i.e. A′[i] =∑dj=1A[(i − 1) · d + j],i = 1, . . . , d. We then compact A by removing A[j · d] for j = 1, . . . , n/d, and bypacking the remaining integers in at most nk(1−1/d) bits. We build our layeredb-ary Fenwick tree Tb(A′) over A′. It is clear that queries on A can be solvedwith a query on Tb(A′) followed by at most d accesses on (the compacted) A.The space of the resulting data structure is nk(1 − 1/d) + Sb(n/d, k + log d) ≤nk + n log dd +2n log bd bits. In order to retain the same query times of our basiclayered structure, we choose d = (1/) logb n for any constant  > 0 and obtaina space occupancy of nk + (n log logb nlogb n+ 2n log blogb n)bits. For b ≤ logO(1) n, thisspace is nk+o(n) bits. Note that—as opposed to existing succinct solutions—thelow-order term does not depend on k.3 Optimal-time sum and updateIn this section we show how to obtain optimal running times for sum and updatequeries in the RAM model. We can directly apply the word-packing techniquesdescribed in [7] to speed-up queries; here we only sketch this strategy, see [7] forfull details. Let us describe the idea on the structure of Section 2.1, and thenplug in sampling to reduce space usage. We divide arrays T jb (A) in blocks ofb− 1 entries, and store one word (w bits) for each such block. We can pack b− 1integers of at most w/(b − 1) bits each (for an opportune b, read below) in theword associated with each block. Since blocks of b − 1 integers fit in a singleword, we can easily answer sum and update queries on them in constant time.sum queries on our overall structure can be answered as described in Section 2.1,except that now we also need to access one of the packed integers at each levelj to correct the value read from T jb (A). To answer update queries, the idea isto perform update operations on the packed blocks of integers in constant timeexploiting bit-parallelism instead of updating at most b− 1 values of T jb (A). Ateach update operation, we transfer one of these integers on T jb (A) (in a cyclicfashion) to avoid overflowing and to achieve worst-case performance. Note thateach packed integer is increased by at most ∆ for at most b − 1 times beforebeing transferred to T jb (A), so we get the constraint (b − 1) log((b − 1)∆) ≤ w.We choose (b−1) = w2(logw+δ) . Then, it is easy to show that the above constraintis satisfied. The number of levels becomes logb n = O(logw/δ n). Since we spendconstant time per level, this is also the worst-case time needed to answer sum andupdate queries on our structure. To analyze space usage we use the correctedformulaSb(1, k) = kSb(n, k) =n(b−1)b · (k + log b) + nwb + Sb(n/b, k + log b)yielding Sb(1, k) ≤ nk + 2n log b + nwb−1 . Replacing b − 1 = w2(logw+δ) we achievenk +O(nδ + n logw) bits of space.We now apply the sampling technique of Section 2.2 with a slight varia-tion. In order to get the claimed space/time bounds, we need to further applybit-parallelism techniques on the packed integers stored in A: using techniquesfrom [5], we can answer sum, search, and update queries in O(1) time on blocksof w/k integers. It follows that we can now use sample rate d = w lognk log(w/δ) with-out affecting query times. After sampling A and building the Fenwick tree abovedescribed over the sums of size-d blocks of A, the overall space is nk(1− 1/d) +Sb(n/d, k+ log d) = nk+n log dd +O(nδd + n logwd ). Note that d ≤ w2k log(w/δ) ≤ w2,so log d ∈ O(logw) and space simplifies to nk + O(nδd + n logwd ). The term nδdequals nδk log(w/δ)w logn . Since δ ≤ w, then δ log(w/δ) ≤ w, and this term thereforesimplifies to nklogn ∈ o(nk). Finally, the term n logwd equals n logw·k log(w/δ)w logn ≤nk(w logn)/(logw)2 ∈ o(nk). The bounds of Theorem 2 follow.Parallelism Note that sum and update queries on our succinct Fenwick treescan be naturally parallelized as all accesses/updates on the levels can be per-formed independently from each other. For sum, we need O(log logb n) furthertime to perform a parallel sum of the logb n partial results. It is not hard to showthat—on architectures with logb n processors—this reduces sum/update times toO(log logb n)/O(b) and O(log logw/δ n)/O(1) in Theorems 1 and 2, respectively.References1. Dietz, P.F.: Optimal algorithms for list indexing and subset rank. In: Proc. 1stWADS. pp. 39–46 (1989)2. Fenwick, P.M.: A new data structure for cumulative frequency tables. Software:Practice and Experience 24(3), 327–336 (1994)3. Fredman, M., Saks, M.: The cell probe complexity of dynamic data structures. In:Proc. 21st STOC. pp. 345–354 (1989)4. Fredman, M.L.: The complexity of maintaining an array and computing its partialsums. Journal of the ACM (JACM) 29(1), 250–260 (1982)5. Hagerup, T.: Sorting and searching on the word ram. In: STACS 98. pp. 366–398.Springer (1998)6. Hon, W.K., Sadakane, K., Sung, W.K.: Succinct data structures for searchablepartial sums with optimal worst-case performance. Theoretical Computer Science412(39), 5176–5186 (2011)7. Patrascu, M., Demaine, E.D.: Logarithmic lower bounds in the cell-probe model.SIAM Journal on Computing 35(4), 932–963 (2006)8. Raman, R., Raman, V., Rao, S.S.: Succinct dynamic data structures. In: Workshopon Algorithms and Data Structures. pp. 426–437. Springer (2001)9. Yao, A.C.: On the complexity of maintaining partial sums. SIAM Journal on Com-puting 14(2), 277–288 (1985)

Archivio della ricerca- LUISS Libera Università Internazionale degli Studi Sociali Guido Carli di Roma

http://orbit.dtu.dk/ws/files/161888756/1705.10987.pdf

Succinct Partial Sums and Fenwick Trees

Abstract

Similar works

Full text

Available Versions

Archivio istituzionale della ricerca - Università degli Studi di Venezia Ca' Foscari

Crossref

Online Research Database In Technology

Archivio della ricerca- LUISS Libera Università Internazionale degli Studi Sociali Guido Carli di Roma