Expected Query Time Research Articles

Orthogonal Range Searching in Moderate Dimensions: k-d Trees and Range Trees Strike Back

We revisit the orthogonal range searching problem and the exact \(\ell _\infty \) nearest neighbor searching problem for a static set of n points when the dimension d is moderately large. We give the first data structure with near linear space that achieves truly sublinear query time when the dimension is any constant multiple of \(\log n\). Specifically, the preprocessing time and space are \(O(n^{1+\delta })\) for any constant \(\delta >0\), and the expected query time is \(n^{1-1/O(c\log c)}\) for \(d=c\log n\). The data structure is simple and is based on a new “augmented, randomized, lopsided” variant of k-d trees. It matches (in fact, slightly improves) the performance of previous combinatorial algorithms that work only in the case of offline queries [(Impagliazzo et al. in arXiv:1401.5512, 2014) and (Chan in Proceedings of the 26th ACM-SIAM Symposium on Discrete Algorithms (SODA), 2015)]. It leads to slightly faster combinatorial algorithms for all-pairs shortest paths in general real-weighted graphs and rectangular Boolean matrix multiplication. In the offline case, we show that the problem can be reduced to the Boolean orthogonal vectors problem and thus admits an \(n^{2-1/O(\log c)}\)-time non-combinatorial algorithm [Abboud et al. in Proceedings of the 26th Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), 2015]. This reduction is also simple and is based on range trees. Finally, we use a similar approach to obtain a small improvement to Indyk’s data structure (J Comput Syst Sci 63(4):627–638, 2001) for approximate\(\ell _\infty \) nearest neighbor search when \(d=c\log n\).

Randomized approximation algorithms for planar visibility counting problem

Given a set S of n disjoint line segments in R2, the visibility counting problem (VCP) is to preprocess S such that the number of segments in S visible from any query point p can be computed quickly. This problem can be solved trivially in O(log⁡n) query time using O(n4log⁡n) preprocessing time and O(n4) space.Gudmundsson and Morin (2010) [10] proposed a 2-approximation algorithm for this problem with a tradeoff between the space and the query time. For any constant 0≤α≤1, their algorithm answers any query in Oϵ(m(1−α)/2) time with Oϵ(m1+α) of preprocessing time and space, where ϵ>0 is a constant that can be made arbitrarily small and Oϵ(f(n))=O(f(n)nϵ) and m=O(n2) is a number that depends on the configuration of the segments.In this paper, we propose two randomized approximation algorithms for VCP. The first algorithm depends on two constants 0≤β≤23 and 0<δ≤1, and the expected preprocessing time, the expected space, and the expected query time are O(m2−3β/2log⁡m), O(m2−3β/2), and O(1δ2mβ/2log⁡m), respectively. The algorithm, in the preprocessing phase, selects a sequence of random samples, whose size and number depend on the tradeoff parameters. When a query point p is given by an adversary unaware of the random sample of our algorithm, it computes the number of visible segments from p, denoted by mp, exactly, if mp≤3δ2mβ/2log⁡(2m). Otherwise, it computes an approximated value, mp′, such that with the probability of at least 1−1m, we have (1−δ)mp≤mp′≤(2+2δ)mp. The preprocessing time and space of the second algorithm are O(n2log⁡n) and O(n2), respectively. This algorithm computes the exact value of mp if mp≤1δ2nlog⁡n, otherwise it returns an approximated value mp″ in expected O(1δ2nlog⁡n) time, such that with the probability at least 1−1log⁡n, we have (1−3δ)mp≤mp″≤(1.5+3δ)mp.

GEMINI: a computationally-efficient search engine for large gene expression datasets.

BackgroundLow-cost DNA sequencing allows organizations to accumulate massive amounts of genomic data and use that data to answer a diverse range of research questions. Presently, users must search for relevant genomic data using a keyword, accession number of meta-data tag. However, in this search paradigm the form of the query – a text-based string – is mismatched with the form of the target – a genomic profile.ResultsTo improve access to massive genomic data resources, we have developed a fast search engine, GEMINI, that uses a genomic profile as a query to search for similar genomic profiles. GEMINI implements a nearest-neighbor search algorithm using a vantage-point tree to store a database of n profiles and in certain circumstances achieves an mathcal {O}(log n) expected query time in the limit. We tested GEMINI on breast and ovarian cancer gene expression data from The Cancer Genome Atlas project and show that it achieves a query time that scales as the logarithm of the number of records in practice on genomic data. In a database with 105 samples, GEMINI identifies the nearest neighbor in 0.05 sec compared to a brute force search time of 0.6 sec.ConclusionsGEMINI is a fast search engine that uses a query genomic profile to search for similar profiles in a very large genomic database. It enables users to identify similar profiles independent of sample label, data origin or other meta-data information.Electronic supplementary materialThe online version of this article (doi:10.1186/s12859-016-0934-8) contains supplementary material, which is available to authorized users.

Persistent Predecessor Search and Orthogonal Point Location on the Word RAM

We answer a basic data structuring question (e.g., raised by Dietz and Raman [1991]): Can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of integers in {1, ..., U } under an arbitrary sequence of n insertions and deletions, with O (log log U ) expected query time and expected amortized update time, and O ( n ) space. The query bound is optimal in U for linear-space structures and improves previous near- O ((log log U ) 2 ) methods. The same method solves a fundamental problem from computational geometry: point location in orthogonal planar subdivisions (where edges are vertical or horizontal). We obtain the first static data structure achieving O (log log U ) worst-case query time and linear space. This result is again optimal in U for linear-space structures and improves the previous O ((log log U ) 2 ) method by de Berg et al. [1995]. The same result also holds for higher-dimensional subdivisions that are orthogonal binary space partitions, and for certain nonorthogonal planar subdivisions such as triangulations without small angles. Many geometric applications follow, including improved query times for orthogonal range reporting for dimensions ≥ 3 on the RAM. Our key technique is an interesting new van-Emde-Boas--style recursion that alternates between two strategies, both quite simple.

Distribution-Aware Compressed Full-Text Indexes

In this paper we address the problem of building a compressed self-index that, given a distribution for the pattern queries and a bound on the space occupancy, minimizes the expected query time within that index space bound. We solve this problem by exploiting a reduction to the problem of finding a minimum weight K-link path in a properly designed Directed Acyclic Graph. Interestingly enough, our solution can be used with any compressed index based on the Burrows-Wheeler transform. Our experiments compare this optimal strategy with several other known approaches, showing its effectiveness in practice.

Entropy, triangulation, and point location in planar subdivisions

A data structure is presented for point location in connected planar subdivisions when the distribution of queries is known in advance. The data structure has an expected query time that is within a constant factor of optimal. More specifically, an algorithm is presented that preprocesses a connected planar subdivision G of size n and a query distribution D to produce a point location data structure for G . The expected number of point-line comparisons performed by this data structure, when the queries are distributed according to D , is H˜ + O (H˜ 1/2 +1) where H˜=H˜( G,D ) is a lower bound on the expected number of point-line comparisons performed by any linear decision tree for point location in G under the query distribution D . The preprocessing algorithm runs in O ( n log n ) time and produces a data structure of size O ( n ). These results are obtained by creating a Steiner triangulation of G that has near-minimum entropy.

ALGORITHMS FOR JUMBLED PATTERN MATCHING IN STRINGS

The Parikh vector p(s) of a string s over a finite ordered alphabet Σ = {a1, …, aσ} is defined as the vector of multiplicities of the characters, p(s) = (p1, …, pσ), where pi = |{j | sj = ai}|. Parikh vector q occurs in s if s has a substring t with p(t) = q. The problem of searching for a query q in a text s of length n can be solved simply and worst-case optimally with a sliding window approach in O(n) time. We present two novel algorithms for the case where the text is fixed and many queries arrive over time. The first algorithm only decides whether a given Parikh vector appears in a binary text. It uses a linear size data structure and decides each query in O(1) time. The preprocessing can be done trivially in Θ(n2) time. The second algorithm finds all occurrences of a given Parikh vector in a text over an arbitrary alphabet of size σ ≥ 2 and has sub-linear expected time complexity. More precisely, we present two variants of the algorithm, both using an O(n) size data structure, each of which can be constructed in O(n) time. The first solution is very simple and easy to implement and leads to an expected query time of [Formula: see text], where m = ∑i qi is the length of a string with Parikh vector q. The second uses wavelet trees and improves the expected runtime to [Formula: see text], i.e., by a factor of log m.

Linear Probing with 5-wise Independence

Hashing with linear probing dates back to the 1950s and is among the most studied algorithms for storing (key, value) pairs. In recent years it has become one of the most important hash table organizations since it uses the cache of modern computers very well. Unfortunately, previous analyses rely either on complicated and space consuming hash functions, or on the unrealistic assumption of free access to a hash function with random and independent function values. Carter and Wegman, in their seminal paper on universal hashing, raised the question of extending their analysis to linear probing. However, we show in this paper that linear probing using a 2-wise independent hash function may have expected logarithmic cost per operation. Recently, Ptraşcu and Thorup have shown that 3- and 4-wise independent hash functions may also give rise to logarithmic expected query time. On the positive side, we show that 5-wise independence is enough to ensure constant expected time per operation. This resolves the question of finding a space and time efficient hash function that provably ensures good performance for hashing with linear probing.

Searching Protein 3-D Structures in Linear Time

One of the most important issues in the post-genomic molecular biology is the analysis of protein three-dimensional (3-D) structures, and searching over the 3-D structure databases of them is becoming more and more important. The root mean square deviation (RMSD) is the most popular similarity measure for comparing two molecular structures. In this article, we propose new theoretically and practically fast algorithms for the basic problem of finding all the substructures of structures in a structure database of chain molecules (such as proteins), whose RMSDs to the query are within a given constant threshold. The best-known worst-case time complexity for the problem is O(N log m), where N is the database size and m is the query size. The previous best-known expected time complexity for the problem is also O(N log m). We also propose a new breakthrough linear-expected-time algorithm. It is not only a theoretically significant improvement over previous algorithms, but also a practically faster algorithm, according to computational experiments. Our experiments over the whole Protein Data Bank (PDB) database show that our algorithm is 3.6-28 times faster than previously known algorithms, to search for similar substructures whose RMSDs are within 1A to queries of ordinary lengths. We also propose a series of preprocessing algorithms that enable faster queries, though there have been no known indexing algorithm whose query time complexity is better than the above O(N log m) bound. One is an O(N log(2)N)-time and O(N log N)-space preprocessing algorithm with expected query time complexity of O(m + N given complex square root of m). Another is an O(N log N)-time and O(N)-space preprocessing algorithm with expected query time complexity of O(N given complex square root of m + m log (N given m)).(1)

Lower bounds for expected-case planar point location

Given a planar polygonal subdivision S, the point location problem is to preprocess S into a data structure so that the cell of the subdivision that contains a given query point can be reported efficiently. Suppose that we are given for each cell z ∈ S the probability p z that a query point lies in z. The entropy H of the resulting discrete probability distribution is a lower bound on the expected-case query time. In addition it is known that it is possible to construct a data structure that answers point-location queries in H + 2 2 H + o ( H ) expected number of comparisons. A fundamental question is how close to the entropy lower bound H the exact optimal expected query time can reach. In this paper we show that if only the probabilities p z are given and no information is available for the probability distribution within each cell, then the optimal expected query time must be at least H + H − O ( 1 ) . Further we show that there exists a query distribution Q over S such that even when we are given complete information on Q, the optimal expected query time must be at least H + 1 64 H − O ( 1 ) . Both these lower bounds differ just by a constant factor in the second order term from the best known upper bound.

Optimal Expected-Case Planar Point Location

Point location is the problem of preprocessing a planar polygonal subdivision $S$ of size $n$ into a data structure in order to determine efficiently the cell of the subdivision that contains a given query point. We consider this problem from the perspective of expected query time. We are given the probabilities $p_z$ that the query point lies within each cell $z \in S$. The entropy $H$ of the resulting discrete probability distribution is the dominant term in the lower bound on the expected-case query time. We show that it is possible to achieve query time $H + O(\sqrt{H}+1)$ with space $O(n)$, which is optimal up to lower order terms in the query time. We extend this result to subdivisions with convex cells, assuming a uniform query distribution within each cell. In order to achieve space efficiency, we introduce the concept of entropy-preserving cuttings.

Expected-Case Complexity of Approximate Nearest Neighbor Searching

Most research in algorithms for geometric query problems has focused on their worst-case performance. However, when information on the query distribution is available, the alternative paradigm of designing and analyzing algorithms from the perspective of expected-case performance appears more attractive. We study the approximate nearest neighbor problem from this perspective. As a first step in this direction, we assume that the query points are sampled uniformly from a hypercube that encloses all the data points; however, we make no assumption on the distribution of the data points. We show that with a simple partition tree, called the sliding-midpoint tree, it is possible to achieve linear space and logarithmic query time in the expected case; in contrast, the data structures known to achieve linear space and logarithmic query time in the worst case are complex, and algorithms on them run more slowly in practice. Moreover, we prove that the sliding-midpoint tree achieves optimal expected query time in a certain class of algorithms.

Fast Range Searching with Delaunay Triangulations

This paper studies the idea of answering range searching queries using simple data structures. The only data structure we need is the Delaunay Triangulation of the input points. The idea is to first locate a vertex of the (arbitrary) query polygon {\cal q} and walk along the boundary of the polygon in the Delaunay Triangulation and report all the points enclosed by the query polygon. For a set of uniformly distributed random points in 2-D and a query polygon the expected query time of this algorithm is O(n^{1/3} + Q + {\bf E}K + L_{r}n^{1/2}), where Q is the size of the query polygon {\cal q}, {\bf E}K = O(n\bcdot area({\cal q})) is the expected number of output points, L_{r} is a parameter related to the shape of the query polygon {\cal q} and n, and L_{r} is always bounded by the sum of the edge lengths of {\cal q}. Theoretically, when L_{r} = O(1/n^{1/6}) the expected query time is O(n^{1/3} + Q + {\bf E}K), which improves the best known average query time for general range searching. Besides the theoretical meaning, the good property of this algorithm is that once the Delaunay Triangulation is given, no additional preprocessing is needed. In order to obtain empirical results, we design a new algorithm for generating random simple polygons within a given domain. Our empirical results show that the constant coefficient of the algorithm is small, at least for the special (practical) cases when the query polygon is either a triangle (simplex range searching) or an axis-parallel box (orthogonal range searching) and for the general case when the query polygons are generated by our new polygon-generating algorithms and their sizes are relatively small.

Nearest Neighbor Queries in Metric Spaces

Given a set S of n sites (points), and a distance measure d , the nearest neighbor searching problem is to build a data structure so that given a query point q , the site nearest to q can be found quickly. This paper gives data structures for this problem when the sites and queries are in a metric space. One data structure, D(S) , uses a divide-and-conquer recursion. The other data structure, M(S,Q) , is somewhat like a skiplist. Both are simple and implementable. The data structures are analyzed when the metric space obeys a certain sphere-packing bound, and when the sites and query points are random and have distributions with an exchangeability property. This property implies, for example, that query point q is a random element of $ S\cup\{q\} $ . Under these conditions, the preprocessing and space bounds for the algorithms are close to linear in n . They depend also on the sphere-packing bound, and on the logarithm of the distance ratio $ \Upsilon(S) $ of S , the ratio of the distance between the farthest pair of points in S to the distance between the closest pair. The data structure M(S,Q) requires as input data an additional set Q , taken to be representative of the query points. The resource bounds of M(S,Q) have a dependence on the distance ratio of S $\cup$ Q . While M(S,Q) can return wrong answers, its failure probability can be bounded, and is decreasing in a parameter K . Here K≤ |Q|/n is chosen when building M(S,Q) . The expected query time for M(S,Q) is O(Klog n)log $\Upsilon(S\cup Q)$ , and the resource bounds increase linearly in K . The data structure D(S) has expected O( log n) O(1) query time, for fixed distance ratio. The preprocessing algorithm for M(S,Q) can be used to solve the all nearest neighbor problem for S in O(n(log n) 2 (log ϒ(S)) 2 ) expected time.

Storage cost considerations in secondary index selection

This paper is concerned with the combined problem of selecting secondary indices for a large relational data base and placing data files and index files in multileveled storage. It is shown that if storage cost consideration is explicitly incorporated, then the optimization becomes nontrivial. An algorithm is presented for minimizing the expected query time under arbitrary storage cost constraints. The formulation includes the consideration that a physical storage block (rather than a single tuple) is the smallest unit of data transfer and that block size is level dependent.