5 research outputs found
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(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
Random Access in Persistent Strings and Segment Selection
We consider compact representations of collections of similar strings that
support random access queries. The collection of strings is given by a rooted
tree where edges are labeled by an edit operation (inserting, deleting, or
replacing a character) and a node represents the string obtained by applying
the sequence of edit operations on the path from the root to the node. The goal
is to compactly represent the entire collection while supporting fast random
access to any part of a string in the collection. This problem captures natural
scenarios such as representing the past history of an edited document or
representing highly-repetitive collections. Given a tree with nodes, we
show how to represent the corresponding collection in space and query time. This improves the previous time-space trade-offs
for the problem. Additionally, we show a lower bound proving that the query
time is optimal for any solution using near-linear space.
To achieve our bounds for random access in persistent strings we show how to
reduce the problem to the following natural geometric selection problem on line
segments. Consider a set of horizontal line segments in the plane. Given
parameters and , a segment selection query returns the th smallest
segment (the segment with the th smallest -coordinate) among the segments
crossing the vertical line through -coordinate . The segment selection
problem is to preprocess a set of horizontal line segments into a compact data
structure that supports fast segment selection queries. We present a solution
that uses space and support segment selection queries in time, where is the number of segments. Furthermore, we prove that
that this query time is also optimal for any solution using near-linear space.Comment: Extended abstract at ISAAC 202
Partial Sums on the Ultra-Wide Word RAM
We consider the classic partial sums problem on the ultra-wide word RAM model
of computation. This model extends the classic -bit word RAM model with
special ultrawords of length bits that support standard arithmetic and
boolean operation and scattered memory access operations that can access
(non-contiguous) locations in memory. The ultra-wide word RAM model captures
(and idealizes) modern vector processor architectures.
Our main result is a new in-place data structure for the partial sum problem
that only stores a constant number of ultraword in addition to the input and
supports operations in doubly logarithmic time. This matches the best known
time bounds for the problem (among polynomial space data structures) while
improving the space from superlinear to a constant number of ultrawords. Our
results are based on a simple and elegant in-place word RAM data structure,
known as the Fenwick tree. Our main technical contribution is a new efficient
parallel ultra-wide word RAM implementation of the Fenwick tree, which is
likely of independent interest.Comment: Extended abstract appeared at TAMC 202
Practical Trade-Offs for the Prefix-Sum Problem
Given an integer array A, the prefix-sum problem is to answer sum(i) queries
that return the sum of the elements in A[0..i], knowing that the integers in A
can be changed. It is a classic problem in data structure design with a wide
range of applications in computing from coding to databases. In this work, we
propose and compare several and practical solutions to this problem, showing
that new trade-offs between the performance of queries and updates can be
achieved on modern hardware.Comment: Accepted by "Software: Practice and Experience", 202