Search

In this paper, we study variants of the classical geometric shortest path problem inside a simple polygon, where we allow a part of the path to go outside the polygon. Let P be a simple polygon consisting of n vertices and let s, t be a pair of points in P. Let int(P) represent the interior of P and let P¯ represent the exterior of P, i.e. int(P)=P\∂(P) and P¯=R2\int(P). For an integer k≥0, we define a k-violation path from s to t to be a path connecting s and t such that its intersection with P¯ consists of at most k segments. There is no restriction in terms of the number of segments of the path within P. The objective is to compute a path of minimum Euclidean length among all possible (≤k)-violation paths from s to t. In this paper, we study this problem for k=1 and propose an algorithm that computes the shortest one-violation path in O(n3) time. We show that for rectilinear polygons, the minimum length rectilinear one-violation path can be computed in O(nlogn) time. We extend the concept of one-violation path to a one-stretch violation path. In this case, the path between s and t is composed of (a) a path in P from s to a vertex u of P, (b) a path in P¯ between u and a vertex v of P, and (c) a path in P between v and t. We show that a minimum length one-stretch violation path can be computed in O(nlognloglogn) time. Next, we introduce one- and two-violation monotone rectilinear path problems among a set of n disjoint axis-parallel rectangular objects. Let s, t be two points in R2 that are not in the interior of any of the objects. In the case of one-violation monotone path problem, the desired rectilinear path from s to t consists of horizontal edges that are directed towards the right and vertical edges that are directed upwards, except for at most one edge. Similarly, in the case of a two-violation monotone path problem, all horizontal edges are directed towards the right except at most one and all vertical edges are directed upwards except at most one. Our algorithms for both of these problems run in O(nlogn) time. [ABSTRACT FROM AUTHOR]

We study geometric variations of the discriminating code problem. In the discrete version of the problem, a finite set of points P and a finite set of objects S are given in R d . The objective is to choose a subset S ∗ ⊆ S of minimum cardinality such that for each point p i ∈ P , the subset S i ∗ ⊆ S ∗ covering p i satisfies S i ∗ ≠ ∅ , and each pair p i , p j ∈ P , i ≠ j , we have S i ∗ ≠ S j ∗ . In the continuous version of the problem, the solution set S ∗ can be chosen freely among a (potentially infinite) class of allowed geometric objects. In the 1-dimensional case ( d = 1 ), the points in P are placed on a horizontal line L, and the objects in S are finite-length line segments aligned with L (called intervals). We show that the discrete version of this problem is NP-complete. This is somewhat surprising as the continuous version is known to be polynomial-time solvable. This is also in contrast with most geometric covering problems, which are usually polynomial-time solvable in one dimension. Still for the 1-dimensional discrete version, we design a polynomial-time 2-approximation algorithm. We also design a PTAS for both discrete and continuous versions in one dimension, for the restriction where the intervals are all required to have the same length. We then study the 2-dimensional case ( d = 2 ) for axis-parallel unit square objects. We show that both continuous and discrete versions are NP-complete, and design polynomial-time approximation algorithms that produce (16 · O P T + 1) -approximate and (64 · O P T + 1) -approximate solutions respectively, using rounding of suitably defined integer linear programming problems. Finally, we apply our techniques to a related variant of the discrete problem, where instead of points and geometric objects we just have a set S of objects. The goal is to select a small subset S ∗ of objects so that all objects of S are discriminated by their intersection with the objects of S ∗ . This problem can be viewed as a graph problem by stating it in terms of the vertices of the geometric intersection graph of S. Under this graph-theoretical form, it is known as the identifying code problem. We show that the identifying code problem for axis-parallel unit square intersection graphs (in d = 2 ) can be solved in the same manner as for the discrete version of the discriminating code problem for unit square objects described above, and all our positive approximation results still hold in this setting. [ABSTRACT FROM AUTHOR]