Search

We consider a random variable expressed as the Euclidean distance between an arbitrary point and a random variable uniformly distributed in a closed and bounded set of a three-dimensional Euclidean space. Four cases are considered for this set: a union of disjoint disks, a union of disjoint balls, a union of disjoint line segments, and the boundary of a polyhedron. In the first three cases, we provide closed-form expressions of the cumulative distribution function and the density. In the last case, we propose two algorithms with complexity O (n ln n) , n being the number of edges of the polyhedron, that computes exactly the cumulative distribution function. An application of these results to probabilistic seismic hazard analysis and extensions are discussed. Finally, we present an open source library, available at https://github.com/vguigues/Areas%5fLibrary , that implements the algorithms presented in this paper. [ABSTRACT FROM AUTHOR]

In the present paper, we propose a novel generalization of the celebrated MMP algorithm in order to find the wavefront propagation and the cut-locus on a convex polyhedron with an emphasis on actual implementation for instantaneous visualization and numerical computation. [ABSTRACT FROM AUTHOR]

In this paper, we consider the distributed version of Support Vector Machine (SVM) under the coordinator model, where all input data (i.e., points in ℝ d space) of SVM are arbitrarily distributed among k nodes in some network with a coordinator which can communicate with all nodes. We investigate two variants of this problem, with and without outliers. For distributed SVM without outliers, we prove a lower bound on the communication complexity and give a distributed (1 −) -approximation algorithm to reach this lower bound, where is a user specified small constant. For distributed SVM with outliers, we present a (1 −) -approximation algorithm to explicitly remove the influence of outliers. Our algorithm is based on a deterministic distributed top t selection algorithm with communication complexity of O (k log (t)) in the coordinator model. [ABSTRACT FROM AUTHOR]

In this paper, we consider an interval coverage problem. We are given intervals of the same length on a line and a line segment on . Each interval has a nonnegative weight. The goal is to move the intervals along such that every point of is covered by at least one interval and the maximum moving cost of all intervals is minimized, where the moving cost of each interval is its moving distance times its weight. Algorithms for the 'unweighted' version of this problem have been given before. In this paper, we present a first-known algorithm for this weighted version and our algorithm runs in time. The problem has applications in mobile sensor barrier coverage, where is the barrier and each interval is the covering interval of a mobile sensor. [ABSTRACT FROM AUTHOR]

One of the important tasks in the analysis of spatio-temporal data collected from moving entities is to find a group: a set of entities that travel together for a sufficiently long period of time. Buchin et al.2 introduce a formal definition of groups, analyze its mathematical structure, and present efficient algorithms for computing all maximal groups in a given set of trajectories. In this paper, we refine their definition and argue that our proposed definition corresponds better to human intuition in certain cases, particularly in dense environments. We present algorithms to compute all maximal groups from a set of moving entities according to the new definition. For a set of n moving entities in ℝ1, specified by linear interpolation in a sequence of τ time stamps, we show that all maximal groups can be computed in O(τ2n4) time. A similar approach applies if the time stamps of entities are not the same, at the cost of a small extra factor of α(n) in the running time, where α denotes the inverse Ackermann function. In higher dimensions, we can compute all maximal groups in O(τ2n5logn) time (for any constant number of dimensions), regardless of whether the time stamps of entities are the same or not. We also show that one τ factor can be traded for a much higher dependence on n by giving a O(τn42n) algorithm for the same problem. Consequently, we give a linear-time algorithm when the number of entities is constant and the input size relates to the number of time stamps of each entity. Finally, we provide a construction to show that it might be difficult to develop an algorithm with polynomial dependence on nand linear dependence on τ. [ABSTRACT FROM AUTHOR]

In 1982, Drezner proposed the (1|1)-centroid problem on the plane, in which two players, called the leader and the follower, open facilities to provide service to customers in a competitive manner. The leader opens the first facility, and the follower opens the second. Customers will each patronize the facility closer to them (with ties broken in favor of the first one), thereby deciding the market share of the two facilities. The goal is to find the best position for the leader’s facility so that its market share is maximized. The best algorithm of this problem is an O(n2logn)-time parametric search approach, which searches over the space of market share values. In the same paper, Drezner also proposed a generalized version of (1|1)-centroid problem by introducing a minimal distance constraint R, such that the follower’s facility is not allowed to be located within a distance R from the leader’s. He proposed an O(n5logn)-time algorithm for this generalized version by identifying O(n4) points as the candidates of the optimal solution and checking the market share for each of them. In this paper, we develop a new parametric search approach searching over the O(n4) candidate points, and present an O(n2logn)-time algorithm for this generalized version, thereby closing the O(n3) gap between the two bounds. [ABSTRACT FROM AUTHOR]

An unfolding of a polyhedron is a single connected planar piece without overlap resulting from cutting and flattening the surface of the polyhedron. Even for orthogonal polyhedra, it is known that edge-unfolding, i.e., cuts are performed only along the edges of a polyhedron, is not sufficient to guarantee a successful unfolding in general. However, if additional cuts parallel to polyhedron edges are allowed, it has been shown that every orthogonal polyhedron of genus zero admits a grid-unfolding with quadratic refinement. Using a new unfolding technique developed in this paper, we improve upon the previous result by showing that linear refinement suffices. For 1-layer orthogonal polyhedra of genus , we show a grid-unfolding algorithm using only additional cuts, affirmatively answering an open problem raised in a recent literature. Our approach not only requires fewer cuts but yields much simpler algorithms. [ABSTRACT FROM AUTHOR]

The Fréchet distance is a well studied and very popular measure of similarity of two curves. The best known algorithms have quadratic time complexity, which has recently been shown to be optimal assuming the Strong Exponential Time Hypothesis (SETH) [Bringmann, FOCS'14]. To overcome the worst-case quadratic time barrier, restricted classes of curves have been studied that attempt to capture realistic input curves. The most popular such class are -packed curves, for which the Fréchet distance has a -approximation in time [Driemel et al., DCG'12]. In dimension this cannot be improved to for any unless SETH fails [Bringmann, FOCS'14]. In this paper, exploiting properties that prevent stronger lower bounds, we present an improved algorithm with time complexity . This improves upon the algorithm by Driemel et al. for any . Moreover, our algorithm's dependence on , and is optimal in high dimensions apart from lower order factors, unless SETH fails. Our main new ingredients are as follows: For filling the classical free-space diagram we project short subcurves onto a line, which yields one-dimensional separated curves with roughly the same pairwise distances between vertices. Then we tackle this special case in near-linear time by carefully extending a greedy algorithm for the Fréchet distance of one-dimensional separated curves. [ABSTRACT FROM AUTHOR]

In this paper, we consider the problem of computing shortest paths of bounded curvature amidst obstacles in the plane. More precisely, given two prescribed initial and final configurations (specifying the location and the direction of travel) and a set of obstacles in the plane, we want to compute a shortest C¹ path joining those two configurations, avoiding the obstacles, and with the further constraint that, on each C² piece, the radius of curvature is at least 1. In this paper, we consider the case of moderate obstacles and present a polynomial-time exact algorithm to solve this problem. [ABSTRACT FROM AUTHOR]

This paper classifies common mobile robot on-line motion planning problems according to their competitive complexity. The competitiveness of an on-line algorithm measures its worst case performance relative to the optimal off-line solution to the problem. Competitiveness usually means constant relative performance. This paper generalizes competitiveness to any functional relationship between on-line performance and optimal off-line solution. The constants in the functional relationship must be scalable and may depend only upon on-line information. Given an on-line task, its competitive complexity class is a pair of lower and upper bounds on the competitive performance of all on-line algorithms for the task, such that the two bounds satisfy the same functional relationship. The paper classifies the following on-line motion planning problems into competitive classes: area coverage, navigation to a target, and on-line search for an optimal path. In particular, it is shown that navigation to a target whose position is either apriori known or recognized upon arrival belongs to a quadratic competitive complexity class. The hardest on-line problem involves navigation in unknown variable traversibility environments. Under certain restriction on traversibility, this last problem belongs to an exponential competitive complexity class. [ABSTRACT FROM AUTHOR]

To better handle situations where additional resources are available to carry out a task, many problems from the manufacturing industry involve dividing a task into a number of smaller tasks, while optimizing a specific objective function. In this paper we consider the problem of partitioning a given set S of n points in the plane into k subsets, S[sub 1], …, S[sub k], such that max[sub 1≤i≤k] MST(S[sub i]) is minimized. Variants of this problem arise in applications from the shipbuilding industry. We show that this problem is NP-hard, and we also present an approximation algorithm for the problem, in the case when k is a fixed constant. The approximation algorithm runs in time O(n log n) and produces a partition that is within a factor (4/3 + ε) of the optimal if k = 2, and a factor (2 + ε) otherwise. [ABSTRACT FROM AUTHOR]

Watermarking techniques for vector graphics dislocate vertices in order to embed imperceptible, yet detectable, statistical features into the input data. The embedding process may result in a change of the topology of the input data, e.g., by introducing self- intersections, which is undesirable or even disastrous for many applications. In this paper we present a watermarking framework for two-dimensional vector graphics that employs conventional watermarking techniques but still provides the guarantee that the topology of the input data is preserved. The geometric part of this framework computes so-called maximum perturbation regions (MPR) of vertices. We propose two efficient algorithms to compute MPRs based on Voronoi diagrams and constrained triangulations. Furthermore, we present two algorithms to conditionally correct the watermarked data in order to increase the watermark embedding capacity and still guarantee topological correctness. While we focus on the watermarking of input formed by straight-line segments, one of our approaches can also be extended to circular arcs. We conclude the paper by demonstrating and analyzing the applicability of our framework in conjunction with two well-known watermarking techniques. [ABSTRACT FROM AUTHOR]

In this paper, we consider the rectilinear one-center problem on uncertain points in the plane. In this problem, we are given a set 𝒫 of n (weighted) uncertain points in the plane and each uncertain point has m possible locations each associated with a probability for the point appearing at that location. The goal is to find a point q ∗ in the plane which minimizes the maximum expected rectilinear distance from q ∗ to all uncertain points of 𝒫 , and q ∗ is called a rectilinear center. We present an algorithm that solves the problem in O (m n) time. Since the input size of the problem is Θ (m n) , our algorithm is optimal. [ABSTRACT FROM AUTHOR]

In this paper, we study the problem of designing robust algorithms for computing the minimum spanning tree, the nearest neighbor graph, and the relative neighborhood graph of a set of points in the plane, under the Euclidean metric. We use the term "robust" to denote an algorithm that can properly handle degenerate configurations of the input (such as co-circularities and collinearities) and that is not affected by errors in the flow of control due to round-off approximations. Existing asymptotically optimal algorithms that compute such graphs are either suboptimal in terms of the arithmetic precision required for the implementation, or cannot handle degeneracies, or are based on complex data structures. We present a unified approach to the robust computation of the above graphs. The approach is a variant of the general region approach for the computation of proximity graphs based on Yao graphs, first introduced in Ref. 43 (A. C.-C. Yao, On constructing minimum spanning trees in k -dimensional spaces and related problems, SIAM J. Comput.11(4) (1982) 721–736). We show that a sparse supergraph of these geometric graphs can be computed in asymptotically optimal time and space, and requiring only double precision arithmetic, which is proved to be optimal. The arithmetic complexity of the approach is measured by using the notion of degree, introduced in Ref. 31 (G. Liotta, F. P. Preparata and R. Tamassia, Robust proximity queries: An illustration of degree-driven algorithm design, SIAM J. Comput.28(3) (1998) 864–889) and Ref. 3 (J. D. Boissonnat and F. P. Preparata, Robust plane sweep for intersecting segments, SIAM J. Comput.29(5) (2000) 1401–1421). As a side effect of our results, we solve a question left open by Katajainen27 (J. Katajainen, The region approach for computing relative neighborhood graphs in the L p metric, Computing40 (1987) 147–161) about the existence of a subquadratic algorithm, based on the region approach, that computes the relative neighborhood graph of a set of points S in the plane under the L 2 metric. [ABSTRACT FROM AUTHOR]

A variation on the classical polygon illumination problem was introduced in [Aichholzer et al. EuroCG'09]. In this variant light sources are replaced by wireless devices called -modems, which can penetrate a fixed number , of 'walls'. A point in the interior of a polygon is 'illuminated' by a -modem if the line segment joining them intersects at most edges of the polygon. It is easy to construct polygons of vertices where the number of -modems required to illuminate all interior points is . However, no non-trivial upper bound is known. In this paper we prove that the number of kmodems required to illuminate any polygon of vertices is . For the cases of illuminating an orthogonal polygon or a set of disjoint orthogonal segments, we give a tighter bound of . Moreover, we present an time algorithm to achieve this bound. [ABSTRACT FROM AUTHOR]

There is strong empirical evidence that human perception of a graph drawing is negatively correlated with the number of edge crossings. However, recent experiments show that one can reduce the negative effect by ensuring that the edges that cross do so at large angles. These experiments have motivated a number of mathematical and algorithmic studies of 'right angle crossing (RAC)' drawings of graphs, where the edges cross each other perpendicularly. In this paper we give an algorithm for constructing RAC drawings of 'outer-1-plane' graphs, that is, topological graphs in which each vertex appears on the outer face, and each edge crosses at most one other edge. The drawing algorithm preserves the embedding of the input graph. This is one of the few algorithms available to construct RAC drawings. [ABSTRACT FROM AUTHOR]

In this paper, we introduce a natural variation of the problem of computing all bichro-matic intersections between two sets of segments. Given two sets R and B of n points in the plane defining two sets of segments, say red and blue, we present an O(n²) time and space algorithm for solving the problem of reporting the set of segments of each color intersected by segments of the other color. We also prove that this problem is 3-Sum hard and provide some illustrative examples of several point configuration. [ABSTRACT FROM AUTHOR]

Necklace maps visualize quantitative data associated with regions by placing scaled symbols, usually disks, without overlap on a closed curve (the necklace) surrounding the map regions. Each region is projected onto an interval on the necklace that contains its symbol. In this paper we address the algorithmic question how to maximize symbol sizes while keeping symbols disjoint and inside their intervals. For that we reduce the problem to a one-dimensional problem which we solve efficiently. Solutions to the one-dimensional problem provide a very good approximation for the original necklace map problem. We consider two variants: Fixed-Order, where an order for the symbols on the necklace is given, and Any-Order where any symbol order is possible. The Fixed-Order problem can be solved in O(n log n) time. We show that the Any-Order problem is NP-hard for certain types of intervals and give an exact algorithm for the decision version. This algorithm is fixed-parameter tractable in the thickness K of the input. Our algorithm runs in O(n log n + n2K4K) time which can be improved to O(n log n + nK2K) time using a heuristic. We implemented our algorithm and evaluated it experimentally. [ABSTRACT FROM AUTHOR]

Let P be a simple polygon of n vertices and let S be a set of N points lying in the interior of P. A geodesic diskGD(p,r) with center p and radius r is the set of points in P that have a geodesic distance ≤ r from p (where the geodesic distance is the length of the shortest polygonal path connection that lies in P). In this paper we present an output sensitive algorithm for finding all N geodesic disks centered at the points of S, for a given value of r. Our algorithm runs in $O((n+(kn)^{\frac{2}{3}}+k)\log^cn)$ time, for some constant c and output size k. It is the basis of a cluster reporting algorithm where geodesic distances are used. [ABSTRACT FROM AUTHOR]

We implement an algorithm for k-clustering for small k in fixed dimensions and report experimental results here. Although the theoretical bounds on the running time are hopeless for 1 + ∊ approximating k-clusters, we note that for dimensions 2 and 3, k-clustering is practical for small k (k ≤ 4) and simple enough shapes. For the purposes of this paper, k is a small fixed constant. [ABSTRACT FROM AUTHOR]

In many applications of terrain analysis, pits or local minima are considered artifacts that must be removed before the terrain can be used. Most of the existing methods for local minima removal work only for raster terrains. In this paper we consider algorithms to remove local minima from polyhedral terrains, by modifying the heights of the vertices. To limit the changes introduced to the terrain, we also try to minimize the total displacement of the vertices. Two approaches to remove local minima are analyzed: lifting vertices and lowering vertices. For the former we show that all local minima in a terrain with n vertices can be removed in the optimal way in $\mathcal{O}(n\,\log \,n)$ time. For the latter we prove that the problem is NP-hard, and present an approximation algorithm with factor 2 ln k, where k is the number of local minima in the terrain. [ABSTRACT FROM AUTHOR]

Geometric intersection searching problems are a well-studied class of query-retrieval problems with many applications. The goal here is to preprocess a set of geometric objects so that the ones that are intersected by a query object can be reported efficiently. Often, a more general version of the problem arises, where the data comes aggregated in disjoint groups and of interest are the groups, not the individual objects, that are intersected by the query object. One approach to a generalized problem is to ignore the grouping, solve the corresponding classical problem, and then infer the groups from the reported answer. However, this is not efficient, since the number of objects intersected can be much larger than the number of groups (i.e., the output size). The problem of designing efficient, output-sensitive query algorithms for generalized intersection searching has received much attention in recent years, and such solutions have been developed for several problems. This paper considers a new class of generalized query-retrieval problems. Specifically, given aggregated geometric data the goal is to report the distinct groups such that no objects from those groups are intersected by the query. Of interest in these generalized non-intersection searching problems are solutions where the query time is sensitive to the output size, i.e., the number of groups reported. Unfortunately, the obvious approaches of (i) solving the corresponding generalized intersection searching problem and reporting the complement, or (ii) solving a generalized intersection searching problem with the complement of the query are either inefficient or incorrect. This paper provides efficient, output-sensitive solutions to several generalized non-intersection searching problems, using techniques such as geometric duality, sparsification, persistence, filtering search, and pruning. [ABSTRACT FROM AUTHOR]

It has been suggested in the literature that ordinary finite-precision floating-point arithmetic is inadequate for geometric computation, and that researchers in numerical analysis may believe that the difficulties of error in geometric computation can be overcome by simple approaches. It is the purpose of this paper to show that these suggestions, based on an example showing failure of a certain algorithm for computing planar convex hulls, are misleading, and why this is so. It is first shown how the now-classical backward error analysis can be applied in the area of computational geometry. This analysis is relevant in the context of uncertain data, which may well be the practical context for computational-geometry algorithms such as, say, those for computing convex hulls. The exposition will illustrate the fact that the backward error analysis does not pretend to overcome the problem of finite precision: it merely provides a way to distinguish those algorithms that overcome the problem to whatever extent it is possible to do so. It is then shown that often the situation in computational geometry is exactly parallel to other areas, such as the numerical solution of linear equations, or the algebraic eigenvalue problem. Indeed, the example mentioned can be viewed simply as an example of the use of an unstable algorithm, for a problem for which computational geometry has already discovered provably stable algorithms. Finally, the paper discusses the implications of these analyses for applications in three-dimensional solid modeling. This is done by considering a problem defined in terms of a simple extension of the planar convex-hull algorithm, namely, the verification of the well-formedness of extruded objects. A brief discussion concerning more difficult problems in solid modeling is also included. [ABSTRACT FROM AUTHOR]

The offsetting process that defines straight skeletons of polygons is generalized to arc polygons, i.e., to planar shapes with piecewise circular boundaries. The offsets are obtained by shrinking or expanding the circular arcs on the boundary in a co-circular manner, and tracing the paths of their endpoints. These paths define the associated shape-preserving skeleton, which decomposes the input object into patches. While the skeleton forms a forest of trees, the patches of the decomposition have a radial monotonicity property. Analyzing the events that occur during the offsetting process is non-trivial; the boundary of the offsetting object may get into self-contact and may even splice. This leads us to an event-driven algorithm for offset and skeleton computation. Several examples (both manually created ones and approximations of planar free-form shapes by arc spline curves) are analyzed to study the practical performance of our algorithm. [ABSTRACT FROM AUTHOR]

Let P be a path graph of n vertices embedded in a metric space. We consider the problem of adding a new edge to P so that the radius of the resulting graph is minimized, where any center is constrained to be one of the vertices of P. Previously, the "continuous" version of the problem where a center may be a point in the interior of an edge of the graph was studied and a linear-time algorithm was known. Our "discrete" version of the problem has not been studied before. We present a linear-time algorithm for the problem. [ABSTRACT FROM AUTHOR]

In Part I, we described an efficient and robust algorithm for computing a common refinement of two surface meshes. In this paper, we present a theoretical verification of the robustness of our algorithm by showing the topological preservation of the intersection principle, which we used to resolve topological inconsistencies caused by numerical errors. To enhance robustness in practice for complex geometries, we further propose techniques to detect and match geometric features, such as ridges, corners, and nonmatching boundaries. We report experimental results using our enhanced overlay algorithm with feature matching for complex geometries from real-world applications. [ABSTRACT FROM AUTHOR]

The article analyzes similarity of closed polygonal curves with respect to the Fréchet metric, which is stronger than the well-known Hausdorff metric and therefore is more appropriate in some applications. An algorithm is described that determines whether the Fréchet distance between two closed polygonal curves with and vertices is less than a given number . The algorithm takes time whereas the previously known algorithms take time. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

Given a real ∊ > 0, an integer g ≥ 0 and a set of points in the plane, we study the problem of computing a piecewise linear functional curve with minimum number of line segments to approximate all points after removing g outliers such that the approximation error is at most ∊. We give an improved algorithm over the previous work. The algorithm is based on two dynamic data structures developed in this paper for the simplicial thickness queries, which are of independent interest. For a set S of simplices in the d-dimensional space ℝd (d ≥ 2 is a constant), the simplicial thickness of a point p is defined as the number of simplices in S that contain p. Given a set P of n points in ℝd, we develop two dynamic data structures to support the following operations. (1) Simplex insertion: Insert a simplex into S. (2) Simplex deletion: Delete a simplex from S. (3) Simplicial thickness query: Given a query simplex σ, compute the minimum simplicial thickness among all points in σ∩P. The first data structure is constructed in O(n1+δ) time, for any constant δ > 0, and can support each operation in O(n1-1/d) time; the second one is con-structed in O(n n) time and can support each operation in O(n1-1/d ( n)O(1)) time. Both data structures use O(n). space. These data structures may find other applications as well. [ABSTRACT FROM AUTHOR]

In this paper, we prove that any finite or infinite family of squares with total area at most 1 can be packed into the rectangle with dimensions and that this rectangle is unique with this property and minimum area. Furthermore, we show that for a finite unit family of n squares which are given sorted by their side lengths, a packing into the rectangle can be found in linear time, which yields an O(n n) time algorithm for the general case. With a restriction to finite unit families, the former statement has been published by D. J. Kleitman and M. Krieger, who - as they state themselves - only provide "a general discussion of the methods used [throughout the proof] and an outline of the major cases". Although they refer their proof to as "being constructive", it is not clear from their presentation how a packing algorithm would look like. Regarding the fact that there are some other results that rely on this statement - some of which even make use of a corresponding packing algorithm - it is important to have an complete and preferably constructive published proof for it. The proof that is presented here is constructive and uses an interesting technique based on quadratic programming which could be applicable to other packing problems as well. [ABSTRACT FROM AUTHOR]

The complexity status of the minimum r-star cover problem for orthogonal polygons had been open for many years, until 2004 when Ch. Worman and J. M. Keil proved it to be polynomially tractable (Polygon decomposition and the orthogonal art gallery problem, IJCGA 17(2) (2007), 105-138). However, since their algorithm has Õ(n17)-time complexity, where Õ(·) hides a polylogarithmic factor, and thus it is not practical, in this paper we present a linear-time 3-approximation algorithm. Our approach is based upon the novel partition of an orthogonal polygon into so-called o-star-shaped orthogonal polygons. [ABSTRACT FROM AUTHOR]

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 n) in the algebraic computation tree model and describe a worst-case O(σn 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 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 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. [ABSTRACT FROM AUTHOR]

No abstract received. [ABSTRACT FROM AUTHOR]

Stoker's theorem states that in a convex polyhedron, the dihedral angles and edge lengths determine the facial angles if the graph is fixed. In this paper, we study under what conditions Stoker's theorem holds for orthogonal polyhedra, obtaining uniqueness and a linear-time algorithm in some cases, and NP-hardness in others. [ABSTRACT FROM AUTHOR]

In this paper we consider the problem of detecting commuting patterns in a trajectory. For this we search for similar subtrajectories. To measure spatial similarity we choose the Fréchet distance and the discrete Fréchet distance between subtrajectories, which are invariant under differences in speed. We give several approximation algorithms, and also show that the problem of finding the 'longest' subtrajectory cluster is as hard as MaxClique to compute and approximate. [ABSTRACT FROM AUTHOR]

Given a set T of n points in ℝ2, a Manhattan network on T is a graph G = (V,E) with the property that all the edges in E are vertical or horizontal line segments connecting points in V ⊇ T and for all p, q ∈ T, the graph contains a path having the length exactly L1 distance between p and q. The Minimum Manhattan Network problem is to find a Manhattan network of minimum length, i.e. minimizing the total length of the line segments of the network. In this paper we present a 2-approximation algorithm with time complexity O(n log n), which improves over a recent combinatorial 2-approximation algorithm with running time O(n2). Moreover, compared with other 2-approximation algorithms using linear programming or dynamic programming techniques, we show that a greedy strategy suffices to obtain a 2-approximation algorithm. [ABSTRACT FROM AUTHOR]

Given a set S of n points in the plane, the disjoint two-rectangle covering problem is to find a pair of disjoint rectangles such that their union contains S and the area of the larger rectangle is minimized. In this paper we consider two variants of this optimization problem: (1) the rectangles are allowed to be reoriented freely while restricting them to be parallel to each other, and (2) one rectangle is restricted to be axis-parallel but the other rectangle is allowed to be reoriented freely. For both of the problems, we present O(n2log n)-time algorithms using O(n) space. [ABSTRACT FROM AUTHOR]

In this paper we study several instances of the alignedk-center problem where the goal is, given a set of points S in the plane and a parameter k ⩾ 1, to find k disks with centers on a line ℓ such that their union covers S and the maximum radius of the disks is minimized. This problem is a constrained version of the well-known k-center problem in which the centers are constrained to lie in a particular region such as a segment, a line, or a polygon. We first consider the simplest version of the problem where the line ℓ is given in advance; we can solve this problem in time O(n log2 n). In the case where only the direction of ℓ is fixed, we give an O(n2log2 n)-time algorithm. When ℓ is an arbitrary line, we give a randomized algorithm with expected running time O(n4log2 n). Then we present (1+ε)-approximation algorithms for these three problems. When we denote T(k, ε) = (k/ε2+(k/ε) log k) log(1/ε), these algorithms run in O(n log k + T(k, ε)) time, O(n log k + T(k, ε)/ε) time, and O(n log k + T(k, ε)/ε2) time, respectively. For k = O(n1/3/log n), we also give randomized algorithms with expected running times O(n + (k/ε2) log(1/ε)), O(n+(k/ε3) log(1/ε)), and O(n + (k/ε4) log(1/ε)), respectively. [ABSTRACT FROM AUTHOR]

This paper discusses the κ-BENDS TRAVELING SALESMAN PROBLEM. In this NP-complete problem, the inputs are n points in the plane and a positive integer κ, and we are asked whether we can travel in straight lines through these n points with at most κ bends. There are a number of applications where minimizing the number of bends in the tour is desirable because bends are considered very costly. We prove that this problem is fixed-parameter tractable (FPT). The proof is based on the kernelization approach. We also consider the RECTILINEAR κ-BENDS TRAVELING SALESMAN PROBLEM, which requires that the line-segments be axis-parallel. 1 Note that a rectilinear tour with κ bends is a cover with κ-line segments, and therefore a cover by lines. We introduce two types of constraints derived from the distinction between line-segments and lines. We derive FPT-algorithms with different techniques and improved time complexity for these cases. [ABSTRACT FROM AUTHOR]

This paper starts the investigation of a constrained version of the point-set embed-dability problem. Let G = (V,E) be a planar graph with n vertices, G′ = (V′,E′) a subgraph of G, and S a set of n distinct points in the plane. We study the problem of computing a point-set embedding of G on S subject to the constraint that G′ is drawn with straight-line edges. Different drawing algorithms are presented that guarantee small curve complexity of the resulting drawing, i.e. a small number of bends per edge. It is proved that: • If G′ is an outerplanar graph and S is any set of points in convex position, a point-set embedding of G on S can be computed such that the edges of E\E′ have at most 4 bends each. • If S is any set of points in general position and G′ is a face of G or if it is a simple path, the curve complexity of the edges of E\E′ is at most 8. • If S is in general position and G′ is a set of k disjoint paths, the curve complexity of the edges of E \ E′ is O(2k). [ABSTRACT FROM AUTHOR]

We study optimization problems for polyhedral terrains in the presence of data imprecision. An imprecise terrain is given by a triangulated point set where the height component of the vertices is specified by an interval of possible values. We restrict ourselves to terrains with a one-dimensional projection, usually referred to as 1.5-dimensional terrains, where an imprecise terrain is given by an x-monotone polyline, and the y-coordinate of each vertex is not fixed but only constrained to a given interval. Motivated mainly by applications in terrain analysis, in this paper we study five different optimization measures related to obtaining smooth terrains, for the 1.5-dimensional case. In particular, we present exact algorithms to minimize and maximize the total turning angle, as well as to minimize the maximum slope change. Furthermore, we also give approximation algorithms to minimize the largest turning angle and to maximize the smallest turning angle. [ABSTRACT FROM AUTHOR]

Many algorithms for applications such as pattern recognition, computer vision, and computer graphics seek to compute actual optimal paths in weighted directed graphs. The standard approach for reporting an actual optimal path is based on building a single-source optimal path tree. A technique by Chen et al.2 was given for a class of problems such that a single actual optimal path can be reported without maintaining any single-source optimal path tree, thus significantly reducing the space bound of those problems with no or little increase in their running time. In this paper, we extend the technique by Chen et al.2 to the generalized problem of reporting many actual optimal paths with different starting and ending vertices in certain directed graphs, and show how this new technique yields improved results on several application problems, such as reconstructing a 3-D surface band bounded by two simple closed curves, finding various constrained segmentation of 2-D medical images, and circular string-to-string correction. We also correct an error in the time/space complexity for the well-cited circular string-to-string correction algorithm12 and give an improved result for this problem. Although the generalized many-path problem seems more difficult than the single-path cases, our algorithms have nearly the same space and time bounds as those of the single-path cases. Our technique is likely to help improve many other optimal paths or dynamic programming algorithms. [ABSTRACT FROM AUTHOR]

In this paper, we introduce a generalized version of the Watchman Route Problem (WRP) where the objective is to plan a continuous closed route in a polygon (possibly with holes) and a set of discrete viewpoints on the planned route such that every point on the polygon boundary is visible from at least one viewpoint. Each planned viewpoint has some associated cost. The total cost to minimize is a weighted sum of the view cost, proportional to the number of viewpoints, and the travel cost, the total length of the route. We call this problem the Generalized Watchman Route Problem or the GWRP. We tackle a restricted nontrivial (it remains NP-hard and log-inapproximable) version of GWRP where each polygon edge is entirely visible from at least one planned viewpoint. We call it Whole Edge Covering GWRP. The algorithm we propose first constructs a graph that connects O(n12) number of sample viewpoints in the polygon, where n is the number of polygon vertices; and then solves the corresponding View Planning Problem with Combined View and Traveling Cost, using an LP-relaxation based algorithm we introduced in [27, 29]. We show that our algorithm has an approximation ratio in the order of either the view frequency, defined as the maximum number of sample viewpoints that cover a polygon edge, or a polynomial of log n, whichever is smaller. [ABSTRACT FROM AUTHOR]

Maximum Independent Set (MIS) and its relative Maximum Weight Independent Set (MWIS) are well-known problems in combinatorial optimization; they are NP-hard even in the geometric setting of unit disk graphs. In this paper, we study the Maximum Area Independent Set (MAIS) problem, a natural restricted version of MWIS in disk intersection graphs where the weight equals the disk area. We obtain: (i) Quantitative bounds on the maximum total area of an independent set relative to the union area; (ii) Practical constant-ratio approximation algorithms for finding an independent set with a large total area relative to the union area. [ABSTRACT FROM AUTHOR]

A room is a simple polygon with a prespecified point, called the door, on its boundary. Search starts at the door, in order to detect any intruder who was in the room at the time it started. Search may be conducted by two guards on the boundary who can detect any intruder that crosses the line connecting them, or by a single searcher with a flashlight, moving on the boundary. A room may or may not be searchable, depending on where the door is placed or no matter where the door is placed. The main contribution of this paper is an O(n log n) time algorithm for finding all intervals on the polygon boundary, if any, where the door can be placed for the resulting room to be searchable, where n is the number of sides of the given polygon. [ABSTRACT FROM AUTHOR]

Geometric spanner is a fundamental structure in computational geometry and plays an important role in many geometric networks design applications. In this paper, we consider a generalization of the classical geometric spanner problem (called segment spanner): Given a set S of n disjoint 2-D segments, find a spanning network GS with minimum size so that for any pair of points in S, there exists a path in GS with length no more than t times their Euclidean distance. Based on a number of interesting techniques (such as weakly dominating set, strongly dominating set, interval cover, and imaginary Steiner points), we present an efficient algorithm to construct the segment spanner. Our approach first identifies a set Q of Steiner points in S and then constructs a point spanner for the set of Steiner points. Our algorithm runs in O(|Q| + n2log n) time and Q is a constant approximation (in terms of its size) of the optimal solution when S has a constant relative separation ratio. The approximation ratio depends on the stretch factor t and the relative separation ratio of S. [ABSTRACT FROM AUTHOR]

Consider a geometric network G in the plane. The dilation between any two vertices x and y in G is the ratio of the shortest path distance between x and y in G to the Euclidean distance between them. The maximum dilation over all pairs of vertices in G is called the dilation of G. In this paper, a randomized algorithm is presented which, when given a polygonal cycle C on n vertices in the plane, computes in O(n log3 n) expected time, the edge of C whose removal results in a polygonal path of smallest possible dilation. It is also shown that the edge whose removal gives a polygonal path of largest possible dilation can be computed in O(n log n) time. If C is a convex polygon, the running time for the latter problem becomes O(n). Finally, it is shown that a (1 - ϵ)-approximation to the dilation of every path C \{e}, for all edges e of C, can be computed in O(n log n) total time. [ABSTRACT FROM AUTHOR]

Given a set of n colored points in IR2 with a total of m (3 ≤ m ≤ n) colors, the problem of identifying the smallest color-spanning object of some predefined shape is studied in this paper. We shall consider two different shapes: (i) corridor and (ii) rectangle of arbitrary orientation. Our proposed algorithm for identifying the smallest color-spanning corridor is simple and runs in O(n2log n) time using O(n) space. A dynamic version of the problem is also studied, where new points may be added, and the narrowest color-spanning corridor at any instance can be reported in O(mn(α(n))2log m) time. Our algorithm for identifying the smallest color-spanning rectangle of arbitrary orientation runs in O(n3log m) time and O(n) space. [ABSTRACT FROM AUTHOR]

Two points a and b are said to be L-visible among a set of polygonal obstacles if the length of the shortest path from a to b avoiding these obstacles is no more than L. For a given convex polygon P with n vertices, Gewali et al.1 addressed the guard placement problem on the boundary of P that covers the maximum area outside to the polygon under L-visibility with P as obstacle. Their proposed algorithm runs in O(n) time if $L\, < \,{{\pi (P)} \over 2}$, where π(P) denotes the perimeter of P. They conjectured that if $L\, \ge \,{{\pi (P)} \over 2}$, then the problem can be solved in subquadratic time. In this paper, we settle the conjecture in the affirmative sense, by proposing an easy to implement linear time algorithm for any arbitrary value of L. [ABSTRACT FROM AUTHOR]