Small Strictly Convex Quadrilateral Meshes of Point Sets

In this paper we give upper and lower bounds on the number of Steiner points required to construct a strictly convex quadrilateral mesh for a planar point set. In particular, we show that 3\lfloorn/2\rfloor internal Steiner points are always sufficient for a convex quadrilateral mesh of n points in the plane. Furthermore, for any given n\geq 4, there are point sets for which \lceil(n–3)/2\rceil–1 Steiner points are necessary for a convex quadrilateral mesh.     

Minimum Weight Convex Steiner Partitions

New tight bounds are presented on the minimum length of planar straight line graphs connecting n given points in the plane and having convex faces. Specifically, we show that the minimum length of a convex Steiner partition for n points in the plane is at most O(log n/log log n) times longer than a Euclidean minimum spanning tree (EMST), and this bound is the best possible. Without Steiner points, the corresponding bound is known to be Θ(log n), attained for n vertices of a pseudo-triangle. We also show that the minimum length convex Steiner partition of n points along a pseudo-triangle is at most O(log log n) times longer than an EMST, and this bound is also the best possible. Our methods are constructive and lead to O(nlog n) time algorithms for computing convex Steiner partitions having O(n) Steiner points and weight within the above worst-case bounds in both cases.     

Grade of Service Steiner Minimum Trees in the Euclidean Plane

Abstract. Let P = {p ₁ , p ₂ , \ldots, p _n } be a set of n {\lilsf terminal points} in the Euclidean plane, where point p _i has a {\lilsf service request of grade} g(p _i ) ∈ {1, 2, \ldots, n} . Let 0 < c(1) < c(2) < ⋅s < c(n) be n real numbers. The {\lilsf Grade of Service Steiner Minimum Tree (GOSST)} problem asks for a minimum cost network interconnecting point set P and some {\lilsf Steiner points} with a service request of grade 0 such that (1) between each pair of terminal points p _i and p _j there is a path whose minimum grade of service is at least as large as \min(g(p _i ), g(p _j )) ; and (2) the cost of the network is minimum among all interconnecting networks satisfying (1), where the cost of an edge with service of grade g is the product of the Euclidean length of the edge with c(g) . The GOSST problem is a generalization of the Euclidean Steiner minimum tree problem where all terminal points have the same grade of service request. When there are only two (three, respectively) different grades of service request by the terminal points, we present a polynomial time approximation algorithm with performance ratio \frac 4 3 ρ (((5+4\sqrt 2 )/7)ρ , respectively), where ρ is the performance ratio achieved by an approximation algorithm for the Euclidean Steiner minimum tree problem. For the general case, we prove that there exists a GOSST that is the minimum cost network under a full Steiner topology or its degeneracies. A powerful interior-point algorithm is used to find a (1+ε) -approximation to the minimum cost network under a given topology or its degeneracies in O(n ^1.5 (log n + log (1/ε))) time. We also prove a lower bound theorem which enables effective pruning in a branch-and-bound method that partially enumerates the full Steiner topologies in search for a GOSST. We then present a k -optimal heuristic algorithm to compute good solutions when the problem size is too large for the branch-and-bound algorithm. Preliminary computational results are presented.     

Steiner Minimal Trees with One Polygonal Obstacle

In this paper we study the Steiner minimal tree T problem for a point set Z with cardinality n and one polygonal obstacle ω in the Euclidean plane. We assume ω touches only one convex path in T that joins two terminals and that the number of extreme points of the obstacle is k . If all degree 2 vertices are omitted, then the topology of T is called the primitive topology of T . Given a full primitive topology along with ω convex, we prove that T can be determined in O(n ² +nlog ² k) time. Further, if ω is nonconvex, we then show that O(n ² +nklog k) time is required. Received April 16, 1996; revised August 18, 1997.     

An O(n log n) Average Time Algorithm for Computing the Shortest Network under a Given Topology

In 1992 F. K. Hwang and J. F. Weng published an O(n ² ) time algorithm for computing the shortest network under a given full Steiner topology interconnecting n fixed points in the Euclidean plane. The Hwang—Weng algorithm can be used to improve substantially existing algorithms for the Steiner minimum tree problem because it reduces the number of different Steiner topologies to be considered dramatically. In this paper we present an improved Hwang—Weng algorithm. While the worst-case time complexity of our algorithm is still O(n ² ) , its average time complexity over all the full Steiner topologies interconnecting n fixed points is O (n log n ). Received August 24, 1996; revised February 10, 1997.     

On Exact Solutions for the Rectilinear Steiner Tree Problem Part I: Theoretical Results

The rectilinear Steiner tree problem asks for a shortest tree connecting given points in the plane with rectilinear distance. The best theoretically analyzed algorithms for this problem are based on dynamic programming and have a running time of O(n ² . . . 2.62 ⁿ ) (Ganley and Cohoon), resp. (Smith). The first algorithm can solve problems of size 27, the second one is highly impractical because of the large constant in the exponent. The best implementations perform poorly even on small problem instances; the best practical results can be reached using a Branch \& Bound approach (Salowe and Warme); this implementation can solve random problems of size 35 within a day, while the dynamic programming approach of Ganley and Cohoon can handle only 27 point examples. In this paper we improve the theoretical worst-case time bound to O(n ² . . . 2.38 ⁿ ) , for random problem instances we prove a running time of α ⁿ with a constant α < 2 . We have implemented our algorithms and can now solve problems of 40 points in a day using a provably good dynamic programming approach, and can solve problems of 55 points with a Branch \& Bound strategy. For exponential-time algorithms, this is an enormous improvement. Received April 2, 1997; revised January 5, 1998.     

On the performance of Dijkstra’s third self-stabilizing algorithm for mutual exclusion and related algorithms

In Dijkstra (Commun ACM 17(11):643–644, 1974) introduced the notion of self-stabilizing algorithms and presented three such algorithms for the problem of mutual exclusion on a ring of n processors. The third algorithm is the most interesting of these three but is rather non intuitive. In Dijkstra (Distrib Comput 1:5–6, 1986) a proof of its correctness was presented, but the question of determining its worst case complexity—that is, providing an upper bound on the number of moves of this algorithm until it stabilizes—remained open. In this paper we solve this question and prove an upper bound of 3\frac1318 n² + O(n){3\frac{13}{18} n^2 + O(n)} for the complexity of this algorithm. We also show a lower bound of 1\frac56 n² - O(n){1\frac{5}{6} n^2 - O(n)} for the worst case complexity. For computing the upper bound, we use two techniques: potential functions and amortized analysis. We also present a new-three state self-stabilizing algorithm for mutual exclusion and show a tight bound of \frac56 n² + O(n){\frac{5}{6} n^2 + O(n)} for the worst case complexity of this algorithm. In Beauquier and Debas (Proceedings of the second workshop on self-stabilizing systems, pp 17.1–17.13, 1995) presented a similar three-state algorithm, with an upper bound of 5\frac34n²+O(n){5\frac{3}{4}n^2+O(n)} and a lower bound of \frac18n²-O(n){\frac{1}{8}n^2-O(n)} for its stabilization time. For this algorithm we prove an upper bound of 1\frac12n² + O(n){1\frac{1}{2}n^2 + O(n)} and show a lower bound of n ²−O(n). As far as the worst case performance is considered, the algorithm in Beauquier and Debas (Proceedings of the second workshop on self-stabilizing systems, pp 17.1–17.13, 1995) is better than the one in Dijkstra (Commun ACM 17(11):643–644, 1974) and our algorithm is better than both.     

Approximation Schemes for Node-Weighted Geometric Steiner Tree Problems

In this paper we introduce a new technique for approximation schemes for geometrical optimization problems. As an example problem, we consider the following variant of the geometric Steiner tree problem. Every point u which is not included in the tree costs a penalty of π(u) units. Furthermore, every Steiner point that we use costs c _S units. The goal is to minimize the total length of the tree plus the penalties. Our technique yields a polynomial time approximation scheme for the problem, if the points lie in the plane. A preliminary version of this paper appeared in the Proceedings of the 8th International Workshop on Approximation Algorithms for Combinatorial Optimization Problems, 2005, 221–232.     

A constructive approach to constrained hexahedral mesh generation

Mitchell proved that a necessary and sufficient condition for the existence of a topological hexahedral mesh constrained to a quadrilateral mesh on the sphere is that the constraining quadrilateral mesh contains an even number of elements. Mitchell’s proof depends on Smale’s theorem on the regularity of curves on compact manifolds. Although the question of the existence of constrained hexahedral meshes has been solved, the known solution is not easily programmable; indeed, there are cases, such as Schneider’s Pyramid, that are not easily solved. Eppstein later utilized portions of Mitchell’s existence proof to demonstrate that hexahedral mesh generation has linear complexity. In this paper, we demonstrate a constructive proof to the existence theorem for the sphere, as well as assign an upper-bound to the constant of the linear term in the asymptotic complexity measure provided by Eppstein. Our construction generates 76 × n hexahedra elements within the solid where n is the number of quadrilaterals on the boundary. The construction presented is used to solve some problems posed by Schneiders and Eppstein. We will also use the results provided in this paper, in conjunction with Mitchell’s Geode-Template, to create an alternative way of creating a constrained hexahedral mesh. The construction utilizing the Geode-Template requires 130 × n hexahedra, but will have fewer topological irregularities in the final mesh.     

Time-Optimal Nearest-Neighbor Computations on Enhanced Meshes

The All Nearest Neighbor problem (ANN, for short) is stated as follows: given a setSof points in the plane, determine for every point inS, a point that lies closest to it. The ANN problem is central to VLSI design, computer graphics, pattern recognition, and image processing, among others. In this paper we propose time-optimal algorithms to solve the ANN problem for an arbitrary set of points in the plane and also for the special case where the points are vertices of a convex polygon. Both our algorithms run on meshes with multiple broadcasting. Our first main contribution is to establish an Ω(logn) time lower bound for the task of solving an arbitraryn-point instance of the ANN problem, even if the points are the vertices of a convex polygon. We obtain our time lower bound results for the CREW-PRAM by using a novel technique involving geometric constructions. These constructions allow us to reduce the well-known OR problem to each of the geometric problems of interest. We then port these time lower bounds to the mesh with multiple broadcasting using simulation results. Our second main contribution is to show that the time lower bound obtained is tight, by exhibiting algorithms solving the problem inO(logn) time on a mesh with multiple broadcasting of sizen×n.     

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 ℝ³ 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 ℝ² to the diameter problem for a point set in ℝ⁷.     

On the reference mapping for quadrilateral and hexahedral finite elements on multilevel adaptive grids

We study the properties of the reference mapping for quadrilateral and hexahedral finite elements. We consider multilevel adaptive grids with possibly hanging nodes which are typically generated by adaptive refinement starting from a regular coarse grid. It turns out that for such grids the reference mapping behaves – up to a perturbation depending on the mesh size – like an affine mapping. As an application, we prove optimal estimates of the interpolation error for discontinuous mapped -elements on quadrilateral and hexahedral grids.     

Hardness and approximation results for packing steiner trees

We study approximation algorithms and hardness of approximation for several versions of the problem of packing Steiner trees. For packing edge-disjoint Steiner trees of undirected graphs, we show APX-hardness for four terminals. For packing Steiner-node-disjoint Steiner trees of undirected graphs, we show a logarithmic hardness result, and give an approximation guarantee ofO (√n logn), wheren denotes the number of nodes. For the directed setting (packing edge-disjoint Steiner trees of directed graphs), we show a hardness result of Θ(m ^1/3/−ɛ) and give an approximation guarantee ofO(m ^1/2/+ɛ), wherem denotes the number of edges. We have similar results for packing Steiner-node-disjoint priority Steiner trees of undirected graphs. Supported by NSERC Grant No. OGP0138432. Supported by an NSERC postdoctoral fellowship, Department of Combinatorics and Optimization at University of Waterloo, and a University start-up fund at University of Alberta.     

Steiner systems <Emphasis Type="Italic">S</Emphasis>(<Emphasis Type="Italic">v,k, k</Emphasis> − 1): Components and rank

For an arbitrary Steiner system S(v, k, t), we introduce the concept of a component as a subset of a system which can be transformed (changed by another subset) without losing the property for the resulting system to be a Steiner system S(v, k, t). Thus, a component allows one to build new Steiner systems with the same parameters as an initial system. For an arbitrary Steiner system S(v, k, k − 1), we provide two recursive construction methods for infinite families of components (for both a fixed and growing k). Examples of such components are considered for Steiner triple systems S(v, 3, 2) and Steiner quadruple systems S(v, 4, 3). For such systems and for a special type of so-called normal components, we find a necessary and sufficient condition for the 2-rank of a system (i.e., its rank over \mathbbF₂\mathbb{F}_2) to grow under switching of a component. It is proved that for k ≥ 5 arbitrary Steiner systems S(v, k, k − 1) and S(v, k, k − 2) have maximum possible 2-ranks.     

Linear Data Structures for Fast Ray-Shooting amidst Convex Polyhedra

We consider the problem of ray shooting in a three-dimensional scene consisting of k (possibly intersecting) convex polyhedra with a total of n facets. That is, we want to preprocess them into a data structure, so that the first intersection point of a query ray and the given polyhedra can be determined quickly. We describe data structures that require preprocessing time and storage (where the notation hides polylogarithmic factors), and have polylogarithmic query time, for several special instances of the problem. These include the case when the ray origins are restricted to lie on a fixed line ℓ ₀, but the directions of the rays are arbitrary, the more general case when the supporting lines of the rays pass through ℓ ₀, and the case of rays orthogonal to some fixed line with arbitrary origins and orientations. We also present a simpler solution for the case of vertical ray-shooting with arbitrary origins. In all cases, this is a significant improvement over previously known techniques (which require Ω(n ²) storage, even when k ≪ n). Work by Haim Kaplan and Natan Rubin has been supported by Grant 975/06 from the Israel Science Fund. Work by Micha Sharir and Natan Rubin was partially supported by NSF Grant CCF-05-14079, by a grant from the U.S.–Israeli Binational Science Foundation, by grant 155/05 from the Israel Science Fund, Israeli Academy of Sciences, by a grant from the AFIRST French–Israeli program, and by the Hermann Minkowski–MINERVA Center for Geometry at Tel Aviv University. A preliminary version of this paper appeared in Proc. 15th Annu. Europ. Sympos. Alg. (2007), 287–298.     

Steiner Trees in General Nonuniform Orientations

In this paper we consider Steiner minimum trees (SMT) in the plane, where the connections can only be along a given set of fixed but arbitrary (not necessarily uniform) orientations. The orientations define a metric, called the general orientation metric, A _σ, where σ is the number of orientations. We prove that in A _σ metric, there exists an SMT whose Steiner points belong to an (n−2)-level grid. This result generalizes a result by Lee and Shen [11], and a result by Du and Hwang [5]. In the former case, the same result was obtained for the special case when all orientations are uniform, while in the latter case the same result was proven for the special case when there are only three arbitrary orientations. We then modify the proof used in the main result for the special case when σ=3, i.e., only three arbitrary orientations are considered, and obtain a better result, which states that there exists an SMT whose Steiner points belong to an -level grid. The result has also been obtained by Lin and Xue [9] using a different approach. Received September 27, 1999; revised August 14, 2000     

θ(1) Time Algorithm for Structural Characterization of Multi-Leveled Images and its Applications on a Reconfigurable Mesh Computer

Given a multi-leveled image of size n × n, stored in a reconfigurable mesh computer of the same size one point per processing element (PE). In this paper, we propose a parallel algorithm for structural characterization of all the components of the image. The algorithm is based on the representation of component contour by straight line segments to reduce the volume of data processing. The resulted contours are simultaneously processed using the contour running approach. The pertinent data obtained after the component characterization are used in the filtering application and to develop an algorithm for the convex hull search for all the image components. Our algorithm is assigned to be implemented on a reconfigurable mesh computer and is of θ(1) time complexity.     

Improved Approximation Algorithms for Maximum Resource Bin Packing and Lazy Bin Covering Problems

In this paper, we study two variants of the bin packing and covering problems called Maximum Resource Bin Packing (MRBP) and Lazy Bin Covering (LBC) problems, and present new approximation algorithms for them. For the offline MRBP problem, the previous best known approximation ratio is \frac65\frac{6}{5} (=1.2) achieved by the classical First-Fit-Increasing (FFI) algorithm (Boyar et al. in Theor. Comput. Sci. 362(1–3):127–139, 2006). In this paper, we give a new FFI-type algorithm with an approximation ratio of \frac8071\frac{80}{71} (≈1.12676). For the offline LBC problem, it has been shown in Lin et al. (COCOON, pp. 340–349, 2006) that the classical First-Fit-Decreasing (FFD) algorithm achieves an approximation ratio of \frac7160\frac{71}{60} (≈1.18333). In this paper, we present a new FFD-type algorithm with an approximation ratio of \frac1715\frac{17}{15} (≈1.13333). Our algorithms are based on a pattern-based technique and a number of other observations. They run in near linear time (i.e., O(nlog n)), and therefore are practical.     

A linear-time algorithm to construct a rectilinear Steiner minimal tree fork-extremal point sets

Ak-extremal point set is a point set on the boundary of ak-sided rectilinear convex hull. Given ak-extremal point set of sizen, we present an algorithm that computes a rectilinear Steiner minimal tree in timeO(k ⁴ n). For constantk, this algorithm runs inO(n) time and is asymptotically optimal and, for arbitraryk, the algorithm is the fastest known for this problem.     

The Baire Partial Quasi-Metric Space: A?Mathematical Tool for Asymptotic Complexity Analysis in Computer Science

In 1994, S.G. Matthews introduced the notion of partial metric space in order to obtain a suitable mathematical tool for program verification (Ann. N.Y. Acad. Sci. 728:183–197, 1994). He gave an application of this new structure to parallel computing by means of a partial metric version of the celebrated Banach fixed point theorem (Theor. Comput. Sci. 151:195–205, 1995). Later on, M.P. Schellekens introduced the theory of complexity (quasi-metric) spaces as a part of the development of a topological foundation for the asymptotic complexity analysis of programs and algorithms (Electron. Notes Theor. Comput. Sci. 1:211–232, 1995). The applicability of this theory to the asymptotic complexity analysis of Divide and Conquer algorithms was also illustrated by Schellekens. In particular, he gave a new proof, based on the use of the aforenamed Banach fixed point theorem, of the well-known fact that Mergesort algorithm has optimal asymptotic average running time of computing. In this paper, motivated by the utility of partial metrics in Computer Science, we discuss whether the Matthews fixed point theorem is a suitable tool to analyze the asymptotic complexity of algorithms in the spirit of Schellekens. Specifically, we show that a slight modification of the well-known Baire partial metric on the set of all words over an alphabet constitutes an appropriate tool to carry out the asymptotic complexity analysis of algorithms via fixed point methods without the need for assuming the convergence condition inherent to the definition of the complexity space in the Schellekens framework. Finally, in order to illustrate and to validate the developed theory we apply our results to analyze the asymptotic complexity of Quicksort, Mergesort and Largesort algorithms. Concretely we retrieve through our new approach the well-known facts that the running time of computing of Quicksort (worst case behaviour), Mergesort and Largesort (average case behaviour) are in the complexity classes O(n²)\mathcal{O}(n^{2}), O(nlog₂(n))\mathcal{O}(n\log_{2}(n)) and O(2(n-1)-log₂(n))\mathcal{O}(2(n-1)-\log_{2}(n)), respectively.