767 research outputs found

    Succinct Data Structures for Chordal Graphs

    Get PDF
    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

    Full text link
    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

    Get PDF
    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

    Get PDF
    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

    Full text link
    We consider the problem of designing succinct data structures for interval graphs with nn vertices while supporting degree, adjacency, neighborhood and shortest path queries in optimal time in the Θ(log⁡n)\Theta(\log n)-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 nlog⁡n−2nlog⁡log⁡n−O(n)n\log{n} - 2n\log\log n - O(n) bits are necessary to represent any unlabeled interval graph GG with nn vertices, answering an open problem of Yang and Pippenger [Proc. Amer. Math. Soc. 2017]. This is augmented by a data structure of size nlog⁡n+O(n)n\log{n} +O(n) 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

    Get PDF
    In the cell probe model with word size 1 (the bit probe model), a static data structure problem is given by a map f:0,1nimes0,1mightarrow0,1f: {0,1}^n imes {0,1}^m ightarrow {0,1}, where 0,1n{0,1}^n is a set of possible data to be stored, 0,1m{0,1}^m is a set of possible queries (for natural problems, we have mllnm ll n) and f(x,y)f(x,y) is the answer to question yy about data xx. A solution is given by a representation phi:0,1nightarrow0,1sphi: {0,1}^n ightarrow {0,1}^s and a query algorithm qq so that q(phi(x),y)=f(x,y)q(phi(x), y) = f(x,y). The time tt of the query algorithm is the number of bits it reads in phi(x)phi(x). In this paper, we consider the case of {em succinct} representations where s=n+rs = n + r for some {em redundancy} rllnr ll n. 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 rr, 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 omega(m)omega(m) lower bounds were known on tt in the general model for explicit functions, even for very small redundancies. By restricting our attention to {em systematic} or {em index} structures phiphi satisfying phi(x)=xcdotphi∗(x)phi(x) = x cdot phi^*(x) for some map phi∗phi^* (where cdotcdot 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
    • 

    corecore