Orthogonal Range Queries Research Articles

Optimal Centrality Computations Within Bounded Clique-Width Graphs

Given an n-vertex m-edge graph G of clique-width at most k, and a corresponding k-expression, we present algorithms for computing some well-known centrality indices (eccentricity and closeness) that run in \({\mathcal {O}}(2^{{\mathcal {O}}(k)}(n+m)^{1+\epsilon })\) time for any \(\epsilon > 0\). Doing so, we can solve various distance problems within the same amount of time, including: the diameter, the center, the Wiener index and the median set. Our run-times match conditional lower bounds of Coudert et al. (SODA’18) under the Strong Exponential-Time Hypothesis. On our way, we get a distance-labeling scheme for n-vertex m-edge graphs of clique-width at most k, using \({\mathcal {O}}(k\log ^2{n})\) bits per vertex and constructible in \(\tilde{\mathcal {O}}(k(n+m))\) time from a given k-expression. Doing so, we match the label size obtained by Courcelle and Vanicat (DAM 2016), while we considerably improve the dependency on k in their scheme. As a corollary, we get an \(\tilde{\mathcal {O}}(kn^2)\)-time algorithm for computing All-Pairs Shortest-Paths on n-vertex graphs of clique-width at most k, being given a k-expression. This partially answers an open question of Kratsch and Nelles (STACS’20). Our algorithms work for graphs with non-negative vertex-weights, under two different types of distances studied in the literature. For that, we introduce a new type of orthogonal range query as a side contribution of this work, that might be of independent interest.

Eccentricity queries and beyond using hub labels

Hub labeling schemes are popular methods for computing distances on road networks and other large complex networks, often answering to a query within a few microseconds for graphs with millions of edges. In this work, we study their algorithmic applications beyond distance queries. Indeed, several implementations of hub labels were reported to have good practical performances, both in terms of pre-processing time and maximum label size. There are also a few relevant graph classes for applications for which we know how to compute hub labelings with sublinear labels in quasi linear time. These positive results raise the question of what can be computed efficiently given a graph and a hub labeling of small maximum label size as input. We focus on eccentricity queries and distance-sum queries, for several versions of these problems on directed weighted graphs, that is in part motivated by their importance in facility location problems. On the negative side, we show conditional lower bounds for these above problems on unweighted undirected sparse graphs, via standard constructions from “Fine-grained” complexity. Specifically, under the Strong Exponential-Time Hypothesis (SETH), answering to these above queries requires Ω(|V|2−o(1)) pre-processing time or Ω(|V|1−o(1)) query time, even if we are given as input a hub labeling of maximum label size in ω(log⁡|V|). However, things take a different turn when the hub labels have a sublogarithmic size. Indeed, for every ε>0 there exists a δε>0 such that the following hold, being given a hub labeling of maximum label size ≤k: after pre-processing the labels in total O(2δε⋅k⋅|V|1+ε) time, we can compute both the eccentricity and the distance-sum of any vertex in O(2δε⋅k⋅|V|ε) time. Our data structure is a novel application of the orthogonal range query framework of Cabello and Knauer (2009) [17]. It can also be applied to the fast global computation of some topological indices. Finally, as a by-product of our approach, on any fixed class of unweighted graphs with bounded expansion, we can decide whether the diameter of an n-vertex graph in the class is at most k in fε(k)⋅n1+ε time for any ε>0, for some “explicit” function fε that depends on ε and the graph class considered. This result is further motivated by the empirical evidence that many classes of complex networks have bounded expansion (Demaine et al., 2019 [24]), and that some of these networks, such as the online social networks, have a relatively small diameter.

A limit field for orthogonal range searches in two-dimensional random point search trees

We consider the cost of general orthogonal range queries in random quadtrees. The cost of a given query is encoded into a (random) function of four variables which characterize the coordinates of two opposite corners of the query rectangle. We prove that, when suitably shifted and rescaled, the random cost function converges uniformly in probability towards a random field that is characterized as the unique solution to a distributional fixed-point equation. We also state similar results for 2-d trees. Our results imply for instance that the worst case query satisfies the same asymptotic estimates as a typical query, and thereby resolve an open question of Chanzy et al. (2001).

Computational Cost Reduction of Nondominated Sorting Using the M-Front

Many multiobjective evolutionary algorithms rely on the nondominated sorting procedure to determine the relative quality of individuals with respect to the population. In this paper, we propose a new method to decrease the cost of this procedure. Our approach is to determine the nondominated individuals at the start of the evolutionary algorithm run and to update this knowledge as the population changes. In order to do this efficiently, we propose a special data structure called the M-front, to hold the nondominated part of the population. The M-front uses the geometric and algebraic properties of the Pareto dominance relation to convert orthogonal range queries into interval queries using a mechanism based on the nearest neighbor search. These interval queries are answered using dynamically sorted linked lists. Experimental results show that our method can perform significantly faster than the state-of-the-art Jensen–Fortin’s algorithm, especially in many-objective scenarios. A significant advantage of our approach is that, if we change a single individual in the population we still know which individuals are dominated and which are not.

Enabling high-dimensional range queries using kNN indexing techniques: approaches and empirical results

Many modern search applications are high-dimensional and depend on efficient orthogonal range queries. These applications span web-based and scientific needs as well as uses for data mining. Although k-nearest neighbor queries are becoming increasingly common due to mobile and geospatial applications, orthogonal range queries in high-dimensional data remain extremely important and relevant. For efficient querying, data is typically stored in an index optimized for either kNN or range queries. This can be problematic when data is optimized for kNN retrieval and a user needs a range query or vice versa. Here, we address the issue of using a kNN-based index for range queries, as well as outline the general computational geometry problem of adapting these systems to range queries. We refer to these methods as space-based decompositions and provide a straightforward heuristic for this problem. Using iDistance as our applied kNN indexing technique, we also develop an optimal (data-based) algorithm designed specifically for its indexing scheme. We compare this method to the suggested naive approach using real world datasets. The data-based algorithm consistently performs better.

Space-efficient representations of rectangle datasets supporting orthogonal range querying

The increasing use of geographic search engines manifests the interest of Internet users in geo-located resources and, in general, in geographic information. This has emphasized the importance of the development of efficient indexes over large geographic databases. The most common simplification of geographic objects used for indexing purposes is a two-dimensional rectangle. Furthermore, one of the primitive operations that must be supported by every geographic index structure is the orthogonal range query, which retrieves all the geographic objects that have at least one point in common with a rectangular query region. In this work, we study several space-efficient representations of rectangle datasets that can be used in the development of geographic indexes supporting orthogonal range queries.

POINT SET DISTANCE AND ORTHOGONAL RANGE PROBLEMS WITH DEPENDENT GEOMETRIC UNCERTAINTIES

Classical computational geometry algorithms handle geometric constructs whose shapes and locations are exact. However, many real-world applications require modeling and computing with geometric uncertainties, which are often coupled and mutually dependent. In this paper we address the relative position of points, point set distance problems, and orthogonal range queries in the plane in the presence of geometric uncertainty. The uncertainty can be in the locations of the points, in the query range, or both, and is possibly coupled. Point coordinates and range uncertainties are modeled with the Linear Parametric Geometric Uncertainty Model (LPGUM), a general and computationally efficient worst-case, first-order linear approximation of geometric uncertainty that supports dependence among uncertainties. We present efficient algorithms for relative points orientation, minimum and maximum pairwise distance, closest pair, diameter, and efficient algorithms for uncertain range queries: uncertain range/nominal points, nominal range/uncertain points, uncertain range/uncertain points, with independent/dependent uncertainties. In most cases, the added complexity is sub-quadratic in the number of parameters and points, with higher complexities for dependent point uncertainties.

On position restricted substring searching in succinct space

We study the position restricted substring searching (PRSS) problem, where the task is to index a text T[0...n-1] of n characters over an alphabet set @S of size @s, in order to answer the following: given a query pattern P (of length p) and two indices @? and r, report all occ@?,r occurrences of P in T[@?...r]. Known indexes take O(nlogn) bits or O(nlog^1^+^@en) bits space, and answer this query in O(p+logn+occ@?,rlogn) time or in optimal O(p+occ@?,r) time respectively, where @e is any positive constant. The main drawback of these indexes is their space requirement of @W(nlogn) bits, which can be much more than the optimal [email protected] bits to store the text T. This paper addresses an open question asked by Makinen and Navarro [LATIN, 2006], which is whether it is possible to design a succinct index answering PRSS queries efficiently. We first study the hardness of this problem and prove the following result: a succinct (or a compact) index cannot answer PRSS queries efficiently in the pointer machine model, and also not in the RAM model unless bounds on the well-researched orthogonal range query problem improve. However, for the special case of sufficiently long query patterns, that is for [email protected](log^2^+^@en), we derive an |CSAf|+|CSAr|+o(n) bits index with optimal query time, where |CSAf| and |CSAr| are the space (in bits) of the compressed suffix arrays (with O(p) time for pattern search) of T and T<- (the reverse of T) respectively. The space can be reduced further to |CSAf|+o(n) bits with a resulting query time will be O(p+occ@?,r+log^3^+^@en). For the general case, where there is no restriction on pattern length, we obtain an O([email protected]^[email protected]) bits index with O(p+occ@?,r+n^@e) query time. We use suffix sampling techniques to achieve these space-efficient indexes.

Kinetic kd-Trees and Longest-Side kd-Trees

We propose a simple variant of kd-trees, called rank-based kd-trees, for sets of $n$ points in $\mathbb{R}^d$. We show that a rank-based kd-tree, like an ordinary kd-tree, supports orthogonal range queries in $O(n^{1-1/d}+k)$ time, where $k$ is the output size. The main advantage of rank-based kd-trees is that they can be efficiently kinetized: the kinetic data structure (KDS) processes $O(n^2)$ events in the worst case, assuming that the points follow constant-degree algebraic trajectories; each event can be handled in $O(\log n)$ time, and each point is involved in $O(1)$ certificates. We also propose a variant of longest-side kd-trees, called rank-based longest-side kd-trees, for sets of points in $\mathbb{R}^2$. Rank-based longest-side kd-trees can be kinetized efficiently as well, and like longest-side kd-trees, they support $\varepsilon$-approximate nearest-neighbor, $\varepsilon$-approximate farthest-neighbor, and $\varepsilon$-approximate range queries with convex ranges in $O((1/\epsilon)\log^2n)$ time. The KDS processes $O(n^3\log n)$ events in the worst case, assuming that the points follow constant-degree algebraic trajectories; each event can be handled in $O(\log^2n)$ time, and each point is involved in $O(\log n)$ certificates.

Réponses à « Commentez ce cas clinique »

We give exact and asymptotic formulae for the average search and access cost of orthogonal range queries on multiattribute trees and doubly chained trees. Our results are also valid for paginated trees, and permit evaluation of the memory cost of the trees.

Approximating the Weight of the Euclidean Minimum Spanning Tree in Sublinear Time

We consider the problem of computing the weight of a Euclidean minimum spanning tree for a set of n points in $\mathbb R^d$. We focus on the setting where the input point set is supported by certain basic (and commonly used) geometric data structures that can provide efficient access to the input in a structured way. We present an algorithm that estimates with high probability the weight of a Euclidean minimum spanning tree of a set of points to within $1 + \eps$ using only $\widetilde{\O}(\sqrt{n} \, \text{poly} (1/\eps))$ queries for constant d. The algorithm assumes that the input is supported by a minimal bounding cube enclosing it, by orthogonal range queries, and by cone approximate nearest neighbor queries.

Dynamic orthogonal range queries in OLAP

We study the problem of pre-computing auxillary information to support on-line range queries for the sum and max functions on a datacube. For a d-dimensional datacube with size n in each dimension, we propose a dynamic range max data structure with O( α d ( s, n) L d ) query time, O( α d ( s, n) L 2 d n d/ L ) update time and O( s d ) storage where L and s are parameters chosen by the user before the construction of the data structure such that L∈{1,…,⌈ log n⌉} and s is a non-negative multiple of n; and α( s, n) is the functional inverse of Ackermann's function. Moreover, the data structure can be initialized in time linear to its size. There are three major techniques employed in designing the data structure, namely, a technique for trading query and update times, a technique for trading query time and storage and a technique for extending one-dimensional data structures to d-dimensional ones. Our techniques are also applicable to range queries over any semigroup and group operation, such as min, sum and count.

Cache Oblivious Distribution Sweeping

&lt;p&gt;We adapt the distribution sweeping method to the cache oblivious model. Distribution sweeping is the name used for a general approach for divide-and-conquer algorithms where the combination of solved subproblems can be viewed as a merging process of streams. We demonstrate by a series of algorithms for specific problems the feasibility of the method in a cache oblivious setting. The problems all come from computational geometry, and are: orthogonal line segment intersection reporting, the all nearest neighbors problem, the 3D maxima problem, computing the measure of a set of axis-parallel rectangles, computing the visibility of a set of line segments from a point, batched orthogonal range queries, and reporting pairwise intersections of axis-parallel rectangles. Our basic building block is a simplified version of the cache oblivious sorting algorithm Funnelsort of Frigo et al., which is of independent interest.&lt;/p&gt;&lt;p&gt; &lt;/p&gt;&lt;p&gt;Full text: http://dx.doi.org/10.1007/3-540-45465-9_37&lt;/p&gt;

EFFICIENT PARALLEL RANGE SEARCHING AND PARTITIONING ALGORITHMS*

We present an optimal parallel construction of the range tree data structure and use this construction to solve several geometric partitioning problems. In the range tree, we show how to perform a count-mode orthogonal range query in 0(log n) time by a single processor and a report mode orthogonal range query in 0(log n) time using 0(1 + log n) processors, where k is the number of points inside the query range. We consider partitioning problems of the following nature. Given a planar point set S (∣S∣ = ri) a measure μacting on 5 and a pair of values μ1 and μ2,the task is to find a partition of S into two components S1 and S2 (S = S1U S2) such that μ(S1) =μ1 for i=1, 2. We consider several measures like diameter under L∞ and l1 metric; area, perimeter of the smallest enclosing axes-parallel rectangle; and the side length of the smallest enclosing axes-parallel square. All our parallel algorithms foi partitioning problems run in 0(log n) time using 0(n) processors. Our algorithms are designed for the CREW PRAM model of parallel computation.

Some properties of optimal cartesian product files for orthogonal range queries

Cartesian product file (CPF) has been proposed as a good multi-attribute file structure. Although designing an optimal CPF for partial match queries (PMQs) has been proven to be NP-hard, some useful properties have been studied for PMQs to help the work. However, a good CPF for PMQs may not be beneficial for orthogonal range queries (ORQs). Therefore, in this paper, we intend to study properties that help the design of a good CPF for ORQs. We found that the problem of designing the optimal CPF for ORQs is related to the problem of finding a minimal- f N-tuple. We will also show some theories of minimal- f N-tuples and develop a method for generating a minimal- f N-tuple. Finally, we will present some properties of the optimal CPF for ORQs from the theories of minimal- f N-tuples.

Optimal multiple key hashing files for orthogonal range queries

This paper mainly explores the design of the multiple key hashing file (MKHF) for orthogonal range retrieval. First, we show the optimal MKHF design problem for orthogonal range queries (ORQs) is NP-hard. Then the performance formula of the MKHF over all possible ORQs is derived. We also present a theoretical lower bound on the performance of the MKHF over all possible ORQs. Finally, a very interesting phenomenon existing in the optimal orthogonal range information retrieval system and the optimal partial match information retrieval system is presented.

Optimal MMI file systems for orthogonal range retrieval

Range queries are more general and significant than partial match queries (PMQs) in the applications of multi-attribute information retrieval. However, almost all efforts devoted to the design of multi-attribute file systems so far were concentrated on PMQs. In this paper, we are concerned with the problem of designing multi-attribute file systems for facilitating orthogonal range queries (ORQs). A greedy method, called the minimum marginal increase (MMI) method, is presented first. Then we derive the formulas of performance of an important static file and an important dynamic file, namely the multiple key hashing (MKH) file and the extendible hashing (EH) file, for answering ORQs. Based upon these performance formulas, we show that the problem of designing optimal file systems for ORQs is indeed a very difficult problem. Further, we show that the presented MMI method can indeed be used to design optimal MKH files and optimal EH files, in some cases, for ORQs. Finally, some experiments show that the MMI method can still be applied to produce “good” MKH files and “good” EH files for the general case.

Hidden-line algorithm based on range searching

An algorithm for curved surfaces is presented that uses a searching technique to eliminate the hidden lines. The visibility determination for the grid points, and the bisection process for the intermediate points, are carried out in such a way that they are reduced to orthogonal range queries, a special form of range-searching problems. Given a point set in the plane and a rectangle, an orthogonal range query asks for the points that lie in the rectangle. A simple cell-list structure is used to process the queries. A linear time growth with respect to the number of grid points can be expected, as shown by test results given for grids of up to 60 000 points.

An algorithm for string matching with a sequence of don't cares

We present an algorithm to search for a pattern containing a sequence of don't care symbols in a preprocessed text. This problem models proximity searching in text searching systems and special searching problems in biological sequences. The main result is that the suffix array data structure of Manber and Myers can be used to reduce this problem to the two-dimensional orthogonal range queries problem. Using known results for the latter problem we obtain a data structure that uses O( n( k + m)) space, where n is the size of the text, k is an upper bound on the number of don't care symbols and m is an upper bound on the number of characters of the pattern appearing before the don't care symbols. The number of occurrences of the pattern can be found in O(log n) time, and a list of all occurrences can be found in time O( n /4 + R), where R is the number of occurrences.

On the design of multiple key hashing files for concurrent orthogonal range retrieval between two disks

This paper concerns the following problem: given a set of multi-attribute records, a fixed number of buckets and a two-disk system, arrange the records into the buckets and then store the buckets between the disks in such a way that, over all possible orthogonal range queries (ORQs), the disk access concurrency is maximized. We shall adopt the multiple key hashing (MKH) method for arranging records into buckets and use the disk modulo (DM) allocation method for storing buckets onto disks. Since the DM allocation method has been shown to be superior to any other allocation methods for allocating an MKH file onto a two-disk system for answering ORQs, the real issue is knowing how to determine an optimal way for organizing the records into buckets based upon the MKH concept. A performance formula that can be used to evaluate the average response time, over all possible ORQs, of an MKH file in a two-disk system using the DM allocation method is first presented. Based upon this formula, it is shown that our design problem is related to a notoriously difficult problem, namely the Prime Number Problem. Then a performance lower bound and an efficient algorithm for designing optimal MKH files in certain cases are presented. It is pointed out that in some cases the optimal MKH file for ORQs in a two-disk system using the DM allocation method is identical to the optimal MKH file for ORQs in a single-disk system and the optimal average response time in a two-disk system is slightly greater than one half of that in a single-disk system.