On counting triangulations in d dimensions

Given a set of n labeled points on S^d, how many combinatorially different geometric triangulations for this point set are there? We show that the logarithm of this number is at most some positive constant times n^d/2+1. Evidence is provided that for even dimensions d the bound can be improved to some constant times n^d/2.     

Continuous bottleneck tree partitioning problems

We study continuous partitioning problems on tree network spaces whose edges and nodes are points in Euclidean spaces. A continuous partition of this space into p connected components is a collection of p subtrees, such that no pair of them intersect at more than one point, and their union is the tree space. An edge-partition is a continuous partition defined by selecting p−1 cut points along the edges of the underlying tree, which is assumed to have n nodes. These cut points induce a partition into p subtrees (connected components). The objective is to minimize (maximize) the maximum (minimum) “size” of the components (the min–max (max–min) problem). When the size is the length of a subtree, the min–max and the max–min partitioning problems are NP-hard. We present O(n² log(min(p,n))) algorithms for the edge-partitioning versions of the problem. When the size is the diameter, the min–max problems coincide with the continuous p-center problem. We describe O(n log³ n) and O(n log² n) algorithms for the max–min partitioning and edge-partitioning problems, respectively, where the size is the diameter of a component.     

Dynamic motion planning in low obstacle density environments

A fundamental task for an autonomous robot is to plan its own motions. Exact approaches to the solution of this motion planning problem suffer from high worst-case running times. The weak and realistic low obstacle density (L.O.D.) assumption results in linear complexity in the number of obstacles of the free space (Van der Stappen et al., 1997). In this paper we address the dynamic version of the motion planning problem in which a robot moves among polygonal obstacles which move along polylines. The obstacles are assumed to move along constant complexity polylines, and to respect the low density property at any given time. We will show that in this situation a cell decomposition of the free space of size O(n²(n) log² n) can be computed in O(n²(n) log² n) time. The dynamic motion planning problem is then solved in O(n²(n) log³ n) time. We also show that these results are close to optimal.     

Lower bounds for computing geometric spanners and approximate shortest paths

We consider the problems of constructing geometric spanners, possibly containing Steiner points, for a set of n input points in d-dimensional space , and constructing spanners and approximate shortest paths among a collection of polygonal obstacles on the plane. The complexities of these problems are shown to be Ω(n log n) in the algebraic computation tree model. Since O(n log n)-time algorithms are known for solving these problems, our lower bounds are tight up to a constant factor.     

Popular distances in 3-space

Let m(n) denote the smallest integer m with the property that any set of n points in Euclidean 3-space has an element such that at most m other elements are equidistant from it. We have that cn^1/3 log log n m(n) n^3/5 β(n), where c> 0 is a constant and β(n) is an extremely slowly growing function, related to the inverse of the Ackermann function.     

Minimal enclosing parallelepiped in 3D

We investigate the problem of finding a minimal volume parallelepiped enclosing a given set of n three-dimensional points. We give two mathematical properties of these parallelepipeds, from which we derive two algorithms of theoretical complexity O(n⁶). Experiments show that in practice our quickest algorithm runs in O(n²) (at least for n10⁵). We also present our application in structural biology.     

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.     

Binary set functions and parity check matrices

We consider the possibility of extending to a family of sets a binary set function defined on a subfamily so that the extension is, in fact, uniquely determined. We place in this context the problem of finding the least integer n(r) such that every linear code of length n with n n(r), dimension n-r and minimum Hamming distance at least 4 has a parity check matrix composed entirely of odd weight columns and answer this problem by showing that n(r) = 5.2^{r − 4} + 1, r4. This result is applied to yield new constructions and bounds for unequal error protection codes with minimum distances 3 and 4.     

Forcing matchings on square grids

Let G be a graph that admits a perfect matching. The forcing number of a perfect matching M of G is defined as the smallest number of edges in a subset S M, such that S is in no other perfect matching. We show that for the 2n × 2n square grid, the forcing number of any perfect matching is bounded below by n and above by n². Both bounds are sharp. We also establish a connection between the forcing problem and the minimum feedback set problem. Finally, we present some conjectures about forcing numbers in other graphs.     

Approximate range searching

The range searching problem is a fundamental problem in computational geometry, with numerous important applications. Most research has focused on solving this problem exactly, but lower bounds show that if linear space is assumed, the problem cannot be solved in polylogarithmic time, except for the case of orthogonal ranges. In this paper we show that if one is willing to allow approximate ranges, then it is possible to do much better. In particular, given a bounded range Q of diameter w and >0, an approximate range query treats the range as a fuzzy object, meaning that points lying within distance w of the boundary of Q either may or may not be counted. We show that in any fixed dimension d, a set of n points in can be preprocessed in O(n+logn) time and O(n) space, such that approximate queries can be answered in O(logn(1/)^d) time. The only assumption we make about ranges is that the intersection of a range and a d-dimensional cube can be answered in constant time (depending on dimension). For convex ranges, we tighten this to O(logn+(1/)^d−1) time. We also present a lower bound for approximate range searching based on partition trees of Ω(logn+(1/)^d−1), which implies optimality for convex ranges (assuming fixed dimensions). Finally, we give empirical evidence showing that allowing small relative errors can significantly improve query execution times.     

On the angular distribution of Gaussian integers with fixed norm

We study the distribution of lattice points a + 1b on the fixed circle a² + b² = n. Our results apply p.p. to the representable integers n, and we supply bounds for the discrepancy of the distribution, and for the maximum and minimum of the angles between consecutive points. As a corollary, we are able to show that when n is representable then it is almost surely representable with min(a, b) small, with an explicit bound.     

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.     

Dominating the complements of bounded tolerance graphs and the complements of trapezoid graphs

We investigate the complexity of several domination problems on the complements of bounded tolerance graphs and the complements of trapezoid graphs. We describe an O(n² log⁵ n) time and O(n²) space algorithm to solve the domination problem on the complement of a bounded tolerance graph, given a square embedding of that graph. We also prove that domination, connected domination and total domination are all NP-complete on co-trapezoid graphs.     

Covering grids and orthogonal polygons with periscope guards

The problem of finding minimum guard covers is NP-hard for simple polygons and open for simple orthogonal polygons. Alternative definitions of visibility have been considered for orthogonal polygons. In this paper we try to determine the complexity of finding guard covers in orthogonal polygons by considering periscope visibility. Under periscope visibility, two points in an orthogonal polygon are visible if there is an orthogonal path with at most one bend that connects them without intersecting the exterior of the polygon. We show that finding minimum periscope guard (as well as k-periscope and s-guard) covers is NP-hard for 3-d grids. We present an O(n³) algorithm for finding minimum periscope guard covers for simple grids and discuss how to extend the algorithm to obtain minimum k-periscope guard covers. We show that this algorithm can be applied to obtain minimum periscope guard covers for a class of simple orthogonal polygon in O(n³).     

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.     

Collision detection for deforming necklaces

In this paper, we propose to study deformable necklaces—flexible chains of balls, called beads, in which only adjacent balls may intersect. Such objects can be used to model macro-molecules, muscles, ropes, and other linear objects in the physical world. We exploit this linearity to develop geometric structures associated with necklaces that are useful for collision detection in physical simulations. We show how these structures can be implemented efficiently and maintained under necklace deformation. In particular, we study a bounding volume hierarchy based on spheres which can be used for collision and self-collision detection of deforming and moving necklaces. As our theoretical and experimental results show, such a hierarchy is easy to compute and, more importantly, is also easy to maintain when the necklace deforms. Using this hierarchy, we achieve a collision detection upper bound of O(nlogn) in two dimensions and O(n^2−2/d) in d-dimensions, d3. To our knowledge, this is the first subquadratic bound proved for a collision detection algorithm using predefined hierarchies. In addition, we show that the power diagram, with the help of some additional mechanisms, can be used to detect self-collisions of a necklace in a way that is complementary to the sphere hierarchy.     

On the generalized Erdös-Szekeres Conjecture — a new upper bound

We prove the following result: For every two natural numbers n and q, n q + 2, there is a natural number E(n, q) satisfying the following:

1. (1) Let S be any set of points in the plane, no three on a line. If |S| E(n, q), then there exists a convex n-gon whose points belong to S, for which the number of points of S in its interior is 0 (mod q).

2. (2) For fixed q, E(n,q) 2^c(q)·n, c(q) is a constant depends on q only.

Part (1) was proved by Bialostocki et al. [2] and our proof is aimed to simplify the original proof. The proof of Part (2) is completely new and reduces the huge upper bound of [2] (a super-exponential bound) to an exponential upper bound.     

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.     

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 problem op n-stationary centers

Among the various problems of celestial mechanics related to the n-body problem, a certain amount of interest attaches to the specific situation wherein a passive gravitational point mass M moves under the assumption that the relative disposition of the other active gravitational masses experiences no large changes.

If the attracting masses are regarded as points and if changes in the relative disposition of the attracting bodies are neglected, one arrives at the problem of the motion of the point M in a field produced by n-stationary attracting centers (the point M here represents the (n+l)-th body).

In addition to the problem of central motion (n = 1), soluble dynamics problems of this category include Euler's case [1] of two (n= 2) stationary Newtonian attracting centers.

This problem, which for a long time was of solely theoretical Interest as an example of an integrable Liouville system [2], has recently been attracting attention in connection with the mechanics of artificial satellites, particularly after it was shown that the potential of an oblate spheroid can be approximated by the potential of two specifically chosen stationary Newtonian attracting centers [3 and 4].

The solution of the problem for n-attracting centers for n ≥ 3 is unknown, except for a single special case of three centers pointed out by Lagrange and considered In greater detail by J.A. Serre [5].

We shall concern ourselves here with problems on the existence of periodic trajectories in the case of n-attracting centers. An arbitrary and not necessarily Newtonian gravitational law will be assumed.

Our analysis is based on the theory of quasiindices of singular force field points as set forth in [60].