Let @math be a set of @math pairwise-disjoint polygonal obstacles with a total of @math vertices in the plane. We consider the problem of building a data structure that can quickly compute an @math shortest obstacle-avoiding path between any two query points @math and @math . Previously, a data structure of size @math was constructed in @math time that answers each two-point query in @math time, i.e., the shortest path length is reported in @math time and an actual path is reported in additional @math time, where @math is the number of edges of the output path. In this paper, we build a new data structure of size @math in @math time that answers each query in @math time. Note that @math for any constant @math . Further, we extend our techniques to the weighted rectilinear version in which the "obstacles" of @math are rectilinear regions with "weights" and allow @math paths to travel through them with weighted costs. Our algorithm answers each query in @math time with a data structure of size @math that is built in @math time (note that @math for any constant @math ).
For the simple polygon case, in which @math is a single simple polygon, all three types of problems have been solved optimally @cite_24 @cite_33 @cite_7 @cite_35 @cite_10 , in both the Euclidean and @math metrics. Specifically, an @math -size data structure can be built in @math time that answers each two-point Euclidean shortest path query in @math time @cite_24 @cite_7 . Since in a simple polygon a Euclidean shortest path is also an @math shortest path @cite_35 , the results in @cite_24 @cite_7 hold for the @math metric as well.
@cite_35 @cite_33 @cite_7 @cite_24 @cite_10
2113370909 2118838969 2031247977 2949937035
In this paper we study two link distance problems for rectilinear paths inside a simple rectilinear polygon P.First, we present a data structure using O(n log n) storage such that a shortest path between two query points can be computed efficiently. If both query points are vertices of P, the query time is O(1 + l), where l is the number of links. If the query points are arbitrary points inside P, then the query time becomes O(log n + l). The resulting path is not only optimal in the rectilinear link metric, but it is optimal in the L1-metric as well. Secondly, it is shown that the rectilinear link diameter of P can be computed in time O(n log n). We also give an approximation algorithm that runs in linear time. This algorithm produces a solution that differs by at most three links from the exact diameter.The solutions are based on a rectilinear version of Chazelle's polygon cutting theorem. This new theorem states that any simple rectilinear polygon can be cut into two rectilinear subpolygons of size at most 34 times the original size, and that such a cut segment can be found in linear time. We present a data structure that allows to preprocess a rectilinear polygon with n vertices such that, for any two query points, the shortest path in the rectilinear link or L1-metric can be reported in time O(log n+k) where k is the link length of the shortest path. If only the distance is of interest, the query time reduces to O(log n). Furthermore, if the query points are two vertices, the distance can be reported in time O(1) and a shortest path can be constructed in time O(1+k). The data structure can be computed in time O(n) and needs O(n) storage. As an application we present a linear time algorithm to compute the diameter of a simple rectilinear polygon w.r.t. the L1-metric. We consider the two-point query version of the fundamental geometric shortest path problem: Given a set h of polygonal obstacles iu the plane, having a total of n vertices, build a data structure such that for any two query points s and t we can efficiently determine the length, d(s,t), of an Euclidean shortest obstacle-avoiding path, *(s,t), from s to t. Additionally, our data structure should allow one to report the path x(s, t), in time proportional to its (combinatorial) size. We present various methods for solving this two-point query problem, including algorithms with o(n), O(log n+h), 0( h log n), O(log’ n) or optimal O(log n) query times, using polynomial-space data structures, with various tradeoffs between space and query time. While severa results have been known for approtimate twepoint Euclidean shortest path queries, it has been a well-publicized open problem to obtain sublinear query time for the exact version of the problem. Our methods also yield data structures for twc+point shortest path queries on nonconvex polyhedral Let @math be a simple polygon of @math vertices. We consider two-point @math shortest path queries in @math . We build a data structure of @math size in @math time such that given any two query points @math and @math , the length of an @math shortest path from @math to @math in @math can be computed in @math time, or in @math time if both @math and @math are vertices of @math , and an actual shortest path can be output in additional linear time in the number of edges of the path. To achieve the result, we propose a mountain decomposition of simple polygons, which may be interesting in its own right. Most importantly, our approach is much simpler than the previous work on this problem.