Algebraic Computation Tree Model Research Articles

Minimum spanning trees in d dimensions

It is shown that a minimum spanning tree of n points in Rd under any fixed Lp-metric, with p = 1, 2,..., ∞, can be computed in optimal O(Td(n, n)) time in the algebraic computational tree model. Td(n, m) denotes the time to find a bichromatic closest pair between n red points and m blue points. The previous bound in the model was O(Td(n, n)log n) and it was proved only for the L2 (Euclidean) metric. Furthermore, for d = 3 it is shown that a minimum spanning tree can be found in O(n log n) time under the L1 and L∞-metrics. This is optimal in the algebraic computation tree model. The previous bound was O(n log n log log n).

A lower bound for computing geometric spanners

It is known that the problem of computing (Steiner) spanners on a set of n points has an Ω(nlog⁡n) lower bound. However, the proof is based on an example of points on the real line. Therefore, if we assume that the points belong to the plane or higher dimensions, and moreover, they are in general position, then the lower bound example does not work.In this paper, we show that the complexity of computing geometric spanners, possibly containing Steiner points, for a set of n points in d-dimensional Euclidean space (Rd) that are in general position is Ω(nlog⁡n), in the algebraic computation tree model. To this end, we reduce the spanner construction to a variant of the closest pair problem which has an Ω(nlog⁡n) lower bound.

An optimal algorithm for the Euclidean bottleneck full Steiner tree problem

Let P and S be two disjoint sets of n and m points in the plane, respectively. We consider the problem of computing a Steiner tree whose Steiner vertices belong to S, in which each point of P is a leaf, and whose longest edge length is minimum. We present an algorithm that computes such a tree in O((n+m)logm) time, improving the previously best result by a logarithmic factor. We also prove a matching lower bound in the algebraic computation tree model.

Isoperimetric triangular enclosures with a fixed angle

In this paper, we study four variants of the famous isoperimetric problem. Given a set S of n > 2 points in the plane (in general position), we show how to compute in O(n2) time, a triangle with maximum (or minimum) area enclosing S among all enclosing triangles with fixed perimeter and one fixed angle. We also show how to compute in O(n2) time, a triangle with maximum (or minimum) perimeter enclosing S among all enclosing triangles with fixed area and one fixed angle. We also provide an Ω (n log n) lower bound for these problems in the algebraic computation tree model.

Minimum-area enclosing triangle with a fixed angle

Given a set S of n points in the plane and a fixed angle 0<ω<π, we show how to find in O(nlogn) time all triangles of minimum area with one angle ω that enclose S. We prove that in general, the solution cannot be written without cubic roots. We also prove an Ω(nlogn) lower bound for this problem in the algebraic computation tree model. If the input is a convex n-gon, our algorithm takes Θ(n) time.

Convex hull of points lying on lines in [formula omitted] time after preprocessing

Motivated by the desire to cope with data imprecision Löffler (2009) [31], we study methods for taking advantage of preliminary information about point sets in order to speed up the computation of certain structures associated with them.In particular, we study the following problem: given a set L of n lines in the plane, we wish to preprocess L such that later, upon receiving a set P of n points, each of which lies on a distinct line of L, we can construct the convex hull of P efficiently. We show that in quadratic time and space it is possible to construct a data structure on L that enables us to compute the convex hull of any such point set P in O(nα(n)log⁎n) expected time. If we further assume that the points are “oblivious” with respect to the data structure, the running time improves to O(nα(n)). The same result holds when L is a set of line segments (in general position). We present several extensions, including a trade-off between space and query time and an output-sensitive algorithm. We also study the “dual problem” where we show how to efficiently compute the (⩽k)-level of n lines in the plane, each of which is incident to a distinct point (given in advance).We complement our results by Ω(nlogn) lower bounds under the algebraic computation tree model for several related problems, including sorting a set of points (according to, say, their x-order), each of which lies on a given line known in advance. Therefore, the convex hull problem under our setting is easier than sorting, contrary to the “standard” convex hull and sorting problems, in which the two problems require Θ(nlogn) steps in the worst case (under the algebraic computation tree model).

COMPUTING THE STRETCH FACTOR AND MAXIMUM DETOUR OF PATHS, TREES, AND CYCLES IN THE NORMED SPACE

The stretch factor and maximum detour of a graph G embedded in a metric space measure how well G approximates the minimum complete graph containing G and the metric space, respectively. In this paper we show that computing the stretch factor of a rectilinear path in L1 plane has a lower bound of Ω(n log n) in the algebraic computation tree model and describe a worst-case O(σn log 2 n) time algorithm for computing the stretch factor or maximum detour of a path embedded in the plane with a weighted fixed orientation metric defined by σ ≥ 2 vectors and a worst-case O(n log d n) time algorithm to d ≥ 3 dimensions in L1-metric. We generalize the algorithms to compute the stretch factor or maximum detour of trees and cycles in O(σn log d+1 n) time. We also obtain an optimal O(n) time algorithm for computing the maximum detour of a monotone rectilinear path in L1 plane.

Max-coloring paths: tight bounds and extensions

The max-coloring problem is to compute a legal coloring of the vertices of a graph G=(V,E) with vertex weights w such that \(\sum_{i=1}^{k}\max_{v\in C_{i}}w(v_{i})\) is minimized, where C 1,…,C k are the various color classes. For general graphs, max-coloring is as hard as the classical vertex coloring problem, a special case of the former where vertices have unit weight. In fact, in some cases it can even be harder: for example, no polynomial time algorithm is known for max-coloring trees. In this paper we consider the problem of max-coloring paths and its generalization, max-coloring skinny trees, a broad class of trees that includes paths and spiders. For these graphs, we show that max-coloring can be solved in time O(|V|+time for sorting the vertex weights). When vertex weights are real numbers, we show a matching lower bound of Ω(|V|log |V|) in the algebraic computation tree model.

Algorithms for testing fault-tolerance of sequenced jobs

We study the problem of testing whether a given set of sequenced jobs can tolerate transient faults. We present efficient algorithms for this problem in several fault models. A fault model describes what types of faults are allowed and specifies assumptions on their frequency. Two types of faults are considered: hidden faults, that can only be detected after a job completes, and exposed faults, that can be detected immediately.First, we give an O(n)-time fault-tolerance testing algorithm, for both exposed and hidden faults, if the number of faults does not exceed a given parameter k.Then we consider the model in which any two faults are separated in time by a gap of length at least Δ, where Δ is at least twice the maximum job length. For exposed faults, we give an O(n)-time algorithm. For hidden faults, we give an algorithm with running time O(n 2), and we prove that if job lengths are distributed uniformly over an interval [0,p max ], then this algorithm’s expected running time is O(n). Our experimental study shows that this linear-time performance extends to other distributions. Finally, we provide evidence that improving the worst-case performance may not be possible, by proving an Ω(n 2) lower bound, in the algebraic computation tree model, on a slight generalization of this problem.

An optimal algorithm for the maximum-density path in a tree

We studied the problem of finding the maximum-density path in a tree. By spine decomposition and a linear-time algorithm for the maximum density segment problem, we developed an O ( n log n ) time algorithm, which improves the previously best result of O ( n log 2 n ) by using centroid decomposition. We also show the time complexity is optimal in the algebraic computation tree model.

An [formula omitted] lower bound for computing the sum of even-ranked elements

Given a sequence A of 2 n real numbers, the EvenRankSum problem asks for the sum of the n values that are at the even positions in the sorted order of the elements in A. We prove that, in the algebraic computation-tree model, this problem has time complexity Θ ( n log n ) . This solves an open problem posed by Michael Shamos at the Canadian Conference on Computational Geometry in 2008.

Algorithms for finding the weight-constrained k longest paths in a tree and the length-constrained k maximum-sum segments of a sequence

In this work, we obtain the following new results: – Given a tree T = ( V , E ) with a length function ℓ : E → R and a weight function w : E → R , a positive integer k , and an interval [ L , U ] , the Weight-Constrained k Longest Paths problem is to find the k longest paths among all paths in T with weights in the interval [ L , U ] . We show that the Weight-Constrained k Longest Paths problem has a lower bound Ω ( V log V + k ) in the algebraic computation tree model and give an O ( V log V + k ) -time algorithm for it. – Given a sequence A = ( a 1 , a 2 , … , a n ) of numbers and an interval [ L , U ] , we define the sum and length of a segment A [ i , j ] to be a i + a i + 1 + ⋯ + a j and j − i + 1 , respectively. The Length-Constrained k Maximum-Sum Segments problem is to find the k maximum-sum segments among all segments of A with lengths in the interval [ L , U ] . We show that the Length-Constrained k Maximum-Sum Segments problem can be solved in O ( n + k ) time.

A Tight Lower Bound for Computing the Diameter of a 3D Convex Polytope

The diameter of a set P of n points in ℝ d is the maximum Euclidean distance between any two points in P. If P is the vertex set of a 3-dimensional convex polytope, and if the combinatorial structure of this polytope is given, we prove that, in the worst case, deciding whether the diameter of P is smaller than 1 requires Ω(nlog n) time in the algebraic computation tree model. It shows that the O(nlog n) time algorithm of Ramos for computing the diameter of a point set in ℝ3 is optimal for computing the diameter of a 3-polytope. We also give a linear time reduction from Hopcroft’s problem of finding an incidence between points and lines in ℝ2 to the diameter problem for a point set in ℝ7.

Geodesic Ham-Sandwich Cuts

Let P be a simple polygon with m vertices, k of which are reflex, and which contains r red points and b blue points in its interior. Let n = m + r + b. A ham-sandwich geodesic is a shortest path in P between two points on the boundary of P that simultaneously bisects the red points and the blue points. We present an O(n log k)-time algorithm for finding a ham-sandwich geodesic. We also show that this algorithm is optimal in the algebraic computation tree model when parameterizing the running time with respect to n and k.

SOME LOWER BOUNDS ON GEOMETRIC SEPARABILITY PROBLEMS

We obtain lower bounds in the algebraic computation tree model for deciding the separability of two disjoint point sets. In particular, we show Ω(n log n) time lower bounds for separability by means of strips, wedges, wedges with apices on a given line, fixed-slopes double wedges, and triangles, which match the complexity of the existing algorithms, and therefore prove their optimality.

LABELING POINTS ON A SINGLE LINE

In this paper, we consider a map labeling problem where the points to be labeled are restricted on a line. It is known that the 1d-4P and the 1d-4S unit-square label placement problem and the Slope-4P unit-square label placement problem can both be solved in linear time and the Slope-4S unit-square label placement problem can be solved in quadratic time in Ref. [8]. We extend the result to the following label placement problem: Slope-4P fixed-height (width) label or elastic label placement problem and present a linear time algorithm for it provided that the input points are given sorted. We further show that if the points are not sorted, the label placement problems have a lower bound of Ω(n log n), where n is the input size, under the algebraic computation tree model. Optimization versions of these point labeling problems are also considered.

On the algebraic complexity of set equality and inclusion

We present a linear-time algorithm in the algebraic computation tree model for checking whether two sets of integers are equal. The significance of this result is in the fact that it shows that set equality testing is computationally easier when the elements of the sets are restricted to be integers. In addition, we show a linear-time algorithm for checking set inclusion in a slightly extended computational model.

Computing an obnoxious anchored segment

In this paper we address a maximin facility location problem for n points in the plane such that the facility is an anchored line segment of a fixed length. We show how to solve this problem in O(n log n) time, which is optimal in the algebraic computation tree model. Other variations of this problem are also discussed.

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 R d , 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.

A lower bound for approximating the geometric minimum weight matching

Given a set S of 2n points in R d , a perfect matching of S is a set of n edges such that each point of S is a vertex of exactly one edge. The weight of a perfect matching is the sum of the Euclidean lengths of all edges. Rao and Smith have recently shown that there is a constant r>1 , that only depends on the dimension d , such that a perfect matching whose weight is less than or equal to r times the weight of a minimum weight perfect matching can be computed in O(n logn) time. We show that this algorithm is optimal in the algebraic computation tree model.