Space-efficient Data Structure Research Articles

Improved Approximate String Matching Using Compressed Suffix Data Structures

Approximate string matching is about finding a given string pattern in a text by allowing some degree of errors. In this paper we present a space efficient data structure to solve the 1-mismatch and 1-difference problems. Given a text T of length n over an alphabet A, we can preprocess T and give an $O(n\sqrt{\log n}\log |A|)$-bit space data structure so that, for any query pattern P of length m, we can find all 1-mismatch (or 1-difference) occurrences of P in O(|A|mlog log n+occ) time, where occ is the number of occurrences. This is the fastest known query time given that the space of the data structure is o(nlog 2 n) bits. The space of our data structure can be further reduced to O(nlog |A|) with the query time increasing by a factor of log e n, for 0<e≤1. Furthermore, our solution can be generalized to solve the k-mismatch (and the k-difference) problem in O(|A| k m k (k+log log n)+occ) and O(log e n(|A| k m k (k+log log n)+occ)) time using an $O(n\sqrt{\log n}\log |A|)$-bit and an O(nlog |A|)-bit indexing data structures, respectively. We assume that the alphabet size |A| is bounded by $O(2^{\sqrt{\log n}})$ for the $O(n\sqrt{\log n}\log |A|)$-bit space data structure.

Space Efficient Dynamic Orthogonal Range Reporting

In this paper we present new space efficient dynamic data structures for orthogonal range reporting. The described data structures support planar range reporting queries in time O(log n+klog log (4n/(k+1))) and space O(nlog log n), or in time O(log n+k) and space O(nlog en) for any e>0. Both data structures can be constructed in O(nlog n) time and support insert and delete operations in amortized time O(log 2n) and O(log nlog log n) respectively. These results match the corresponding upper space bounds of Chazelle (SIAM J. Comput. 17, 427–462, 1988) for the static case. We also present a dynamic data structure for d-dimensional range reporting with search time O(log d−1n+k), update time O(log dn), and space O(nlog d−2+en) for any e>0. The model of computation used in our paper is a unit cost RAM with word size log n.

New text indexing functionalities of the compressed suffix arrays

New text indexing functionalities of the compressed suffix arrays are proposed. The compressed suffix array proposed by Grossi and Vitter is a space-efficient data structure for text indexing. It occupies only O( n) bits for a text of length n; however it also uses the text itself that occupies n log 2| A| bits for the alphabet A . In this paper we modify the data structure so that pattern matching can be done without any access to the text. In addition to the original functions of the compressed suffix array, we add new operations search, decompress and inverse to the compressed suffix arrays. We show that the new index can find occ occurrences of any substring P of the text in O(| P|log n+ occlog ϵ n) time for any fixed 1⩾ ϵ>0 without access to the text. The index also can decompress a part of the text of length m in O( m+log ϵ n) time. For a text of length n on an alphabet A such that | A|= polylog(n) , our new index occupies only O(nH 0+n loglog| A|) bits where H 0⩽ log| A| is the order-0 entropy of the text. Especially for ϵ=1 the size is nH 0+O(n loglog| A|) bits. Therefore the index will be smaller than the text, which means we can perform fast queries from compressed texts.

Efficient Search for Approximate Nearest Neighbor in High Dimensional Spaces

We address the problem of designing data structures that allow efficient search for approximate nearest neighbors. More specifically, given a database consisting of a set of vectors in some high dimensional Euclidean space, we want to construct a space-efficient data structure that would allow us to search, given a query vector, for the closest or nearly closest vector in the database. We also address this problem when distances are measured by the L1 norm and in the Hamming cube. Significantly improving and extending recent results of Kleinberg, we construct data structures whose size is polynomial in the size of the database and search algorithms that run in time nearly linear or nearly quadratic in the dimension. (Depending on the case, the extra factors are polylogarithmic in the size of the database.)

A time and space efficient data structure for string searching on large texts

Suffix tree and suffix array are data structures that allow fast search in a large static text. By using the suffix tree data structure we can find all k occurrences of a pattern w in a text of length n in time O(¦w¦ + k). The same problem can be solved by using the suffix array data structure in time O(¦w¦ + log(n) + k) . Thus suffix trees perform better than suffix arrays with respect to the search time. On the other hand suffix trees require as much as four times more memory space than suffix arrays. We propose a new data structure, the augmented suffix array, that allows searching in O(¦w¦ + log log(n) + k) time and requires about the same memory space as the suffix array. Moreover, in case of very large texts, most of the new data structure and the text itself can be stored in secondary memory without compromising search operation efficiency. This is not the case for both suffix trees and suffix arrays.

Using a multiple storage quad tree on a hierarchical VLSI compaction scheme

A graph-generating algorithm and the experimental results of a hierarchical mask-layout-compaction scheme based on a plane-sweep algorithm, a fast region-query and a space-efficient data structure called the hierarchical multiple-storage quad tree are presented. For a mask-layout design, a rectangle is used as the primary element of the layout. Hence, in the hierarchical mask-compaction scheme, the graph-generating algorithm is based on the edges of rectangles rather than the central lines of symbols for the symbolic-compaction design. The plane-sweep algorithm is also called a dynamic event scheduling algorithm and can be applied to solve some other problems in the field of computational geometry and image processing. The efficiencies of the plane-sweep algorithm and the graph-generating algorithm are dependent on the region-query operations of the spatial data structure. By using the improved multiple storage quad tree as the spatial data structure in the system, the mask-layout compactor has been accomplished in a practically linear time performance in terms of the rectangles in the source layout.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

New algorithms based on a multiple storage quadtree for hierarchical compaction of VLSI mask layout

This paper presents the algorithms, implementation, and performance of a hierarchical mask compactor based on a fast region-query and space-efficient data structure called the multiple storage quadtree. Unlike symbolic compaction, the proposed mask compaction is based on rectangles rather than symbols. A new method of generating the constraint graph by using a sweeping-line algorithm in two-dimensional space is proposed in detail. Some important features of the mask compactor, such as error tolerance, mixed constraint, grid freeness, and hierarchical design and amalgamation, are described. Experimental results show that the proposed system successfully accomplishes layout compaction with almost linear time complexity in terms of the rectangles in the source layout.

Efficient axis-translation of binary digital pictures by blocks in linear quadtree representation

For binary digital pictures with large all-black fragments, the linear quadtree representation is a space-efficient data structure on which many time-efficient algorithms, such border-determination and filling, have been implemented. Translation—moving the picture bodily in a fixed direction—was originally done by converting each pixel into bit-map form. More recently, a recursive translation-rotation algorithm has appeared which makes better use of the hierarchical nature of the data structure, together with a time-complexity bound expressed in terms of the output. We present a nonrecursive translation algorithm with the same asymptotic worst-case time-complexity bound as the recursive algorithm, but which turns out to execute significantly faster than either of the previous algorithms. We generalize this algorithm to higher dimensional pictures, and we express the time-complexity in terms of the input data.

Space searching for intersecting objects

Determining or counting geometric objects that intersect another geometric query object is at the core of algorithmic problems in a number of applied areas of computer science. This article presents a family of space-efficient data structures that realize sublinear query time for points, line segments, lines and polygons in the plane, and points, line segments, planes, and polyhedra in three dimensions.

A new random number generator from permutation groups

We describe a new random number generator, RPGM, which is based on the cryptographic system PGM invented by Magliveras in 1976 and subsequently studied by Magliveras and Surkan [10]. PGM relies on a certain method of machine representation for permutation groups. This method allows for encryption and decryption algorithms based on a space-efficient data structure which is called a logarithmic signature for the group. The efficacy of RPGM is studied by means of an extensive analysis of generated data of 100,000 numbers using the Mathieu groupM 24 in its 5-transitive representation on 24 points.

New trie data structures which support very fast search operations

A new data structure called the q-fast trie is introduced. Given a set of N records whose keys are distinct nonnegative integers less than some initially specified bound M, a q-fast trie uses space O( N) and time O(√log M) for insertions, deletions, and all the retrieval operations commonly associated with binary trees. A simpler but less space efficient data structure called the p-fast trie is defined.