767 research outputs found
Succinct Data Structures for Chordal Graphs
We study the problem of approximate shortest path queries in chordal graphs and give a n log n + o(n log n) bit data structure to answer the approximate distance query to within an additive constant of 1 in O(1) time.
We study the problem of succinctly storing a static chordal graph to answer adjacency, degree, neighbourhood and shortest path queries. Let G be a chordal graph with n vertices. We design a data structure using the information theoretic minimal n^2/4 + o(n^2) bits of space to support the queries:
- whether two vertices u,v are adjacent in time f(n) for any f(n) in omega(1).
- the degree of a vertex in O(1) time.
- the vertices adjacent to u in (f(n))^2 time per neighbour
- the length of the shortest path from u to v in O(nf(n)) tim
From Theory to Practice: Plug and Play with Succinct Data Structures
Engineering efficient implementations of compact and succinct structures is a
time-consuming and challenging task, since there is no standard library of
easy-to- use, highly optimized, and composable components. One consequence is
that measuring the practical impact of new theoretical proposals is a difficult
task, since older base- line implementations may not rely on the same basic
components, and reimplementing from scratch can be very time-consuming. In this
paper we present a framework for experimentation with succinct data structures,
providing a large set of configurable components, together with tests,
benchmarks, and tools to analyze resource requirements. We demonstrate the
functionality of the framework by recomposing succinct solutions for document
retrieval.Comment: 10 pages, 4 figures, 3 table
Proving Tree Algorithms for Succinct Data Structures
Succinct data structures give space-efficient representations of large amounts of data without sacrificing performance. They rely on cleverly designed data representations and algorithms. We present here the formalization in Coq/SSReflect of two different tree-based succinct representations and their accompanying algorithms. One is the Level-Order Unary Degree Sequence, which encodes the structure of a tree in breadth-first order as a sequence of bits, where access operations can be defined in terms of Rank and Select, which work in constant time for static bit sequences. The other represents dynamic bit sequences as binary balanced trees, where Rank and Select present a low logarithmic overhead compared to their static versions, and with efficient insertion and deletion. The two can be stacked to provide a dynamic representation of dictionaries for instance. While both representations are well-known, we believe this to be their first formalization and a needed step towards provably-safe implementations of big data
Succinct Data Structures in the Realm of GIS
Presented at the 4th XoveTIC Conference, A Coruña, Spain, 7â8 October 2021.[Abstract] Geographic Information Systems (GIS) have spread all over our technological environment in the last decade. The inclusion of GPS technologies in everyday portable devices along with the creation of massive shareable geographical data banks has boosted the rise of geoinformatics. Despite the technological maturity of this field, there are still relevant research challenges concerning efficient information storage and representation. One of the most powerful techniques to tackle these issues is designing new Succinct Data Structures (SDS). These structures are defined by three main characteristics: they use a compact representation of the data, they have self-index properties and, as a consequence, they do not need decompression to process the enclosed information. Thus, SDS are not only capable of storing geographical data using as little space as possible, but they can also solve queries efficiently without any previous decompression. This work introduces how SDS can be successfully applied in the GIS context through several novel approaches and practical use cases.This work is partially funded by the CITIC research center funded by Xunta/FEDER-UE 2014-2020 Program, ED431G 2019/01. MICINN(PGE/ERDF) [EXTRA-Compact: PID2020-114635RB-I00]Xunta de Galicia; ED431G 2019/0
Succinct Data Structures for Families of Interval Graphs
We consider the problem of designing succinct data structures for interval
graphs with vertices while supporting degree, adjacency, neighborhood and
shortest path queries in optimal time in the -bit word RAM
model. The degree query reports the number of incident edges to a given vertex
in constant time, the adjacency query returns true if there is an edge between
two vertices in constant time, the neighborhood query reports the set of all
adjacent vertices in time proportional to the degree of the queried vertex, and
the shortest path query returns a shortest path in time proportional to its
length, thus the running times of these queries are optimal. Towards showing
succinctness, we first show that at least bits
are necessary to represent any unlabeled interval graph with vertices,
answering an open problem of Yang and Pippenger [Proc. Amer. Math. Soc. 2017].
This is augmented by a data structure of size bits while
supporting not only the aforementioned queries optimally but also capable of
executing various combinatorial algorithms (like proper coloring, maximum
independent set etc.) on the input interval graph efficiently. Finally, we
extend our ideas to other variants of interval graphs, for example, proper/unit
interval graphs, k-proper and k-improper interval graphs, and circular-arc
graphs, and design succinct/compact data structures for these graph classes as
well along with supporting queries on them efficiently
The Cell Probe Complexity of Succinct Data Structures
In the cell probe model with word size 1 (the bit probe model), a
static data structure problem is given by a map
,
where is a set of possible data to be stored,
is a set of possible queries (for natural problems, we
have ) and is
the answer to question about data .
A solution is given by a
representation and a query algorithm
so that . The time of the query algorithm
is the number of bits it reads in .
In this paper, we consider the case of {em succinct} representations
where for some {em redundancy} .
For
a boolean version of the problem of polynomial
evaluation with preprocessing of coefficients, we show a lower bound on
the redundancy-query time tradeoff of the form
[ (r+1) t geq Omega(n/log n).]
In particular, for very small
redundancies , we get an almost optimal lower bound stating that the
query algorithm has to inspect almost the entire data structure
(up to a logarithmic factor).
We show similar lower bounds for problems satisfying a certain
combinatorial property of a coding theoretic flavor.
Previously, no lower bounds were known on
in the general model for explicit functions, even for very small
redundancies.
By restricting our attention to {em systematic} or {em index}
structures satisfying for some
map (where denotes concatenation) we show
similar lower bounds on the redundancy-query time tradeoff
for the natural data structuring problems of Prefix Sum
and Substring Search
- âŠ