Computing rectangle enclosures

The rectangle enclosure problem is the problem of determining the subset of n iso-oriented planar rectangles that enclose a query rectangle Q. In this paper, we use a three layered data structure which is a combination of Range and Priority search trees and answers both the static and dynamic cases of the problem. Both the cases use O(n> log² n) space. For the static case, the query time is O(log² n log log n + K). The dynamic case is supported in O(log³ n + K) query time using O(log³ n) amortized time per update. K denotes the size of the answer. For the d-dimensional space the results are analogous. The query time is O(log^2d-2 n log log n + K) for the static case and O(log^2d-1 n + K) for the dynamic case. The space used is O(n> log^2d-2 n) and the amortized time for an update is O(log^2d-1 n). The existing bounds given for a class of problems which includes the present one, are O(log^2d n + K) query time, O(log^2d n) time for an insertion and O(log^2d-1 n) time for a deletion.     

Linear time algorithms for the weighted tailored 2-partition problem and the weighted 2-center problem under l∞-distance

In this paper, the weighted tailored 2-partition problem and the weighted 2-center problem under l_∞-distance are considered. An O(2^d−1·d·n) algorithm to solve the weighted tailored 2-partition problem and an O(d²·n + d²·log*d) time algorithm to solve the weighted 2-center problem in the d-dimensional case are presented.     

On determining the congruence of point sets in d dimensions

This paper considers the following problem: given two point sets A and B (|A| = |B| = n) in d dimensional Euclidean space, determine whether or not A is congruent to B. This paper presents an O(n^(d−1)/2 log n) time randomized algorithm. The birthday paradox, which is well-known in combinatorics, is used effectively in this algorithm. Although this algorithm is Monte-Carlo type (i.e., it may give a wrong result), this improves a previous O(n^d−2 log n) time deterministic algorithm considerably. This paper also shows that if d is not bounded, the problem is at least as hard as the graph isomorphism problem in the sense of the polynomiality. Several related results are described too.     

Characterization of Laborde-Mulder graphs (extended odd graphs)

The identification of diametrical vertices in the d-dimensional hypercube (d 3) leads to a (0, 2)-graph of degree d on 2^d−1 vertices and of diameter d/2 namely the extended odd graph (or Laborde-Mulder graph) for odd values of d, and the half-cube for even values of d. In this paper we prove that the diameter of a (0, 2)-graph of degree d on 2^d−1 vertices is at least d/2 , and when d is odd the equality holds if and only if the graph is a Laborde-Mulder graph.     

Complexity of projected images of convex subdivisions

Let S be a subdivision of ^d into n convex regions. We consider the combinatorial complexity of the image of the (k - 1)-skeleton of S orthogonally projected into a k-dimensional subspace. We give an upper bound of the complexity of the projected image by reducing it to the complexity of an arrangement of polytopes. If k = d − 1, we construct a subdivision whose projected image has Ω(n^(3d−2)/2) complexity, which is tight when d 4. We also investigate the number of topological changes of the projected image when a three-dimensional subdivision is rotated about a line parallel to the projection plane.     

On embedding an outer-planar graph in a point set

Given an n-vertex outer-planar graph G and a set P of n points in the plane, we present an O(nlog³n) time and O(n) space algorithm to compute a straight-line embedding of G in P, improving upon the algorithm in [8,12] that requires O(n²) time. Our algorithm is near-optimal as there is an Ω(nlogn) lower bound for the problem [4]. We present a simpler O(nd) time and O(n) space algorithm to compute a straight-line embedding of G in P where lognd2n is the length of the longest vertex disjoint path in the dual of G. Therefore, the time complexity of the simpler algorithm varies between O(nlogn) and O(n²) depending on the value of d. More efficient algorithms are presented for certain restricted cases. If the dual of G is a path, then an optimal Θ(nlogn) time algorithm is presented. If the given point set is in convex position then we show that O(n) time suffices.     

Triangular range counting query in 2D and its application in finding k nearest neighbors of a line segment

We present an efficient algorithm for finding k nearest neighbors of a query line segment among a set of points distributed arbitrarily on a two dimensional plane. Along the way to finding this algorithm, we have obtained an improved triangular range searching technique in 2D. Given a set of n points, we preprocess them to create a data structure using O(n²) time and space, such that given a triangular query region Δ, the number of points inside Δ can be reported in O(logn) time. Finally, this triangular range counting technique is used for finding k nearest neighbors of a query straight line segment in O(log²n+k) time.     

On the multisearching problem for hypercubes

In this paper we give improved bounds for the multisearch problem on a hypercube. This is a parallel search problem where the elements in the structure S to be searched are totally ordered, but where it is not possible to compare in constant time any two given queries q and q′. More precisely, we are given on a n-processor hypercube a sorted n-element sequence S, and a set Q of n queries, and we need to find for each query q Q its location in the sorted S. We present an improved algorithm for the multisearch problem, one that takes O(log n(log log n)³) time on a n-processor hypercube. This problem is fundamental in computational geometry, for example it models planar point location in a slab. We give as application a trapezoidal decomposition algorithm with the same time complexity on a n log n-processor hypercube. The hypercube model for which we claim our bounds is the standard one, SIMD, with O(1) memory registers per processor, and with one-port communication. Each register can store O(log n) bits, so that a processor knows its ID.     

Efficient text fingerprinting via Parikh mapping

We consider the problem of fingerprinting text by sets of symbols. Specifically, if S is a string, of length n, over a finite, ordered alphabet Σ, and S′ is a substring of S, then the fingerprint of S′ is the subset φ of Σ of precisely the symbols appearing in S′. In this paper we show efficient methods of answering various queries on fingerprint statistics. Our preprocessing is done in time O(n|Σ|lognlog|Σ|) and enables answering the following queries:

(1)Given an integer k, compute the number of distinct fingerprints of size k in time O(1).

(2)Given a set φΣ, compute the total number of distinct occurrences in S of substrings with fingerprint φ in time O(|Σ|logn).

     

Bounds on a class of partial partitions of a vector space over gf(2):a graph theoretical approach

A collection Q of linearly independent w-suhicfs of the n-dimensional vector space V(n) over GF(2) is a w-quilt if whenever X and Y are distinct elements of Q, then X is disjoint from the linear span of Y. The main problem is to determine the maximum possibility cardinality of a w-quilt in V(n) for fixed w and n. Here a graph T(Q) is associated with each quilt Q. The connected components of T(Q) are shown to be complete graphs and the structure of the subquilts corresponding to these components is completely determined. By use of Ramsey type arguments these results are shown to lead to new upper bounds on the cardinality of a w-quilt in V(n) where n = w + 2, a case of particular interest.     

Efficient visibility queries in simple polygons

We present a method of decomposing a simple polygon that allows the preprocessing of the polygon to efficiently answer visibility queries of various forms in an output sensitive manner. Using O(n³logn) preprocessing time and O(n³) space, we can, given a query point q inside or outside an n vertex polygon, recover the visibility polygon of q in O(logn+k) time, where k is the size of the visibility polygon, and recover the number of vertices visible from q in O(logn) time.

The key notion behind the decomposition is the succinct representation of visibility regions, and tight bounds on the number of such regions. These techniques are extended to handle other types of queries, such as visibility of fixed points other than the polygon vertices, and for visibility from a line segment rather than a point. Some of these results have been obtained independently by Guibas, Motwani and Raghavan [18] .     

The connectivity of a graph on uniform points on [0,1]

A random graph G_n(x) is constructed on independent random points U₁,…,U_n distributed uniformly on [0,1]^d, d1, in which two distinct such points are joined by an edge if the l_∞-distance between them is at most some prescribed value 0<x<1. The connectivity distance c_n, the smallest x for which G_n(x) is connected, is shown to satisfy

(1)

For d2, the random graph G_n(x) behaves like a d-dimensional version of the random graphs of Erdös and Rényi, despite the fact that its edges are not independent: c_n/d_n→1, a.s., as n→∞, where d_n is the largest nearest-neighbor link, the smallest x for which G_n(x) has no isolated vertices.     

3-D vertical ray shooting and 2-D point enclosure, range searching, and arc shooting amidst convex fat objects

We present a new data structure for a set of n convex simply-shaped fat objects in the plane, and use it to obtain efficient and rather simple solutions to several problems including (i) vertical ray shooting—preprocess a set of n non-intersecting convex simply-shaped flat objects in 3-space, whose xy-projections are fat, for efficient vertical ray shooting queries, (ii) point enclosure—preprocess a set C of n convex simply-shaped fat objects in the plane, so that the k objects containing a query point p can be reported efficiently, (iii) bounded-size range searching— preprocess a set C of n convex fat polygons, so that the k objects intersecting a “not-too-large” query polygon can be reported efficiently, and (iv) bounded-size segment shooting—preprocess a set C as in (iii), so that the first object (if exists) hit by a “not-too-long” oriented query segment can be found efficiently. For the first three problems we construct data structures of size O(λ_s(n)log³n), where s is the maximum number of intersections between the boundaries of the (xy-projections) of any pair of objects, and λ_s(n) is the maximum length of (n, s) Davenport-Schinzel sequences. The data structure for the fourth problem is of size O(λ_s(n)log²n). The query time in the first problem is O(log⁴n), the query time in the second and third problems is O(log³n + klog²n), and the query time in the fourth problem is O(log³n).

We also present a simple algorithm for computing a depth order for a set as in (i), that is based on the solution to the vertical ray shooting problem. (A depth order for , if exists, is a linear order of , such that, if K₁, K₂ and K₁ lies vertically above K₂, then K₁ precedes K₂.) Unlike the algorithm of Agarwal et al. (1995) that might output a false order when a depth order does not exist, the new algorithm is able to determine whether such an order exists, and it is often more efficient in practical situations than the former algorithm.     

Space reduction and an extension for a hidden line elimination algorithm

A simple intersection sensitive algorithm for the hidden line elimination problem, was presented by Nurmi in 1985. This algorithm has O((n + I) logn) time and space complexities, where n is the number of edges in the input scene and I is the number of their intersections on the projection plane. We describe a method that reduces the space requirements of the algorithm to O(n) while retaining the time complexity of O((n+I) logn). Furthermore we show that the algorithm can be easily extended to handle the more general problem of hidden surface removal.     

Label placement by maximum independent set in rectangles

Motivated by the problem of labeling maps, we investigate the problem of computing a large non-intersecting subset in a set of n rectangles in the plane. Our results are as follows. In O(n log n) time, we can find an O(log n)-factor approximation of the maximum subset in a set of n arbitrary axis-parallel rectangles in the plane. If all rectangles have unit height, we can find a 2-approximation in O(n log n) time. Extending this result, we obtain a (1 + 1/k)-approximation in time O(n log n + n^2k−1) time, for any integer k ≥ 1.     

On the degree of the inverse of an automorphism of the affine space

We study the degree of the inverse of an automorphism f of the affine n-space over a -algebra k, in terms of the degree d of f and of other data. For n = 1, we obtain a sharp upper bound for deg (f^{− 1}) in terms of d and of the nilpotency index of the ideal generated by the coefficients of f^′'. For n = 2 and arbitrary d≥ 3, we construct a (triangular) automorphism f of Jacobian one such that deg(f^{− 1}) > d. This answers a question of A. van den Essen (see [3]) and enables us to deduce that some schemes introduced by authors to study the Jacobian conjecture are not reduced. Still for n = 2, we give an upper bound for deg (f^{− 1}) when f is triangular. Finally, in the case d = 2 and any n, we complete a result of G. Meisters and C. Olech and use it to give the sharp bound for the degree of the inverse of a quadratic automorphism, with Jacobian one, of the affine 3-space.     

Fast approximations for sums of distances, clustering and the Fermat–Weber problem

We describe two data structures that preprocess a set S of n points in (d constant) so that the sum of Euclidean distances of points in S to a query point q can be quickly approximated to within a factor of . This preprocessing technique has several applications in clustering and facility location. Using it, we derive an O(nlogn) time deterministic and O(n) time randomized -approximation algorithm for the so called Fermat–Weber problem in any fixed dimension.     

Some closed form formulae for the intersection of two special matrices under the star order

In this note we present closed form formulae for the intersection A ∧ B under the star order, for certain pairs of special matrices. In particular, it is shown that for two m×n partial isometries P and QP∧Q=P[I-(I-P^*Q)^†(I-P^*Q)]. Some further possible representations for P∧Q are considered.     

A faster 2-approximation algorithm for the minmax p-traveling salesmen problem on a tree

Given an edge-weighted tree T and an integer p1, the minmax p-traveling salesmen problem on a tree T asks to find p tours such that the union of the p tours covers all the vertices. The objective is to minimize the maximum of length of the p tours. It is known that the problem is NP-hard and has a (2−2/(p+1))-approximation algorithm which runs in O(p^p−1n^p−1) time for a tree with n vertices. In this paper, we consider an extension of the problem in which the set of vertices to be covered now can be chosen as a subset S of vertices and weights to process vertices in S are also introduced in the tour length. For the problem, we give an approximation algorithm that has the same performance guarantee, but runs in O((p−1)!·n) time.     

On parallel rectilinear obstacle- avoiding paths

We give improved space and processor complexities for the problem of computing, in parallel, a data structure that supports queries about shortest rectilinear obstacle-avoiding paths in the plane, where the obstacles are disjoint rectangles. That is, a query specifies any source and destination in the plane, and the data structure enables efficient processing of the query. We now can build the data structure with O(n²/log n) CREW PRAM processors, as opposed to the previous O(n²), and with O(n²) space, as opposed to the previous O(n²(log n)²). The time complexity remains unchanged, at O((log n)²). As before, the data structure we compute enables a query to be processed in O(log n) time, by one processor for obtaining a path length, or by O(k/log n) processors for retrieving a shortest path itself, where k is the number of segments on that path. The new ideas that made our improvement possible include a new partitioning scheme of the recursion tree, which is used to schedule the computations performed on that tree. Since a number of other related shortest paths problems are solved using this technique as a subroutine our improvement translates into a similar improvement in the complexities of these problems as well.