This paper describes new methods for maintaining a point-location data structure for a dynamically-changing monotone subdivision S. The main approach is based on the maintenance of two interlaced spanning trees, one for S and one for the graphtheoretic planar dual of S. Queries are answered by using a centroid decomposition of the dual tree to drive searches in the primal tree. These trees are maintained via the link-cut trees structure of Sleator and Tarjan, leading to a scheme that achieves vertex insertion/deletion in O(log n) time, insertion/deletion of k-edge monotone chains in O(log n + k) time, and answers queries in O(log 2 n) time, with O(n) space, where n is the current size of subdivision S. The techniques described also allow for the dual operations expand and contract to be implemented in O(log n) time, leading to an improved method for spatial point-location in a 3-dimensional convex subdivision. In addition, the interlaced-tree approach is applied to on-line point-lo...

Abstract. We describe a new technique for dynamically maintaining the trapezoidal decomposition of a connected planar map dX/ [ with n vertices and apply it to the development of a unified dynamic data structure that supports pointlocation, ray-shooting, and shortest-path queries in A4. The space requirement is O(n log n). Point-location queries take time O(log n). Ray-shooting and shortest-path queries take time O(log n) (plus O(k) time if the k edges of the shortest path are reported in addition to its length). Updates consist of insertions and deletions of vertices and edges, and take O(log n) time (amortized for vertex updates). This is the first polylog-time dynamic data structure for shortest-path and ray-shooting queries. It is also the first dynamic point-location data structure for connected planar maps that achieves optimal query time. Key words, point location, ray shooting, shortest path, computational geometry, dynamic algorithm

In this paper a dynamic technique for locating a point in a monotone planar subdivision, whose current number of vertices is n, is presented. The (complete set of) update operations are insertion of a point on an edge and of a chain of edges between two vertices, and their reverse operations. The data structure uses space O(n). The query time is O(log n), the time for insertion/deletion of a point is O(log n), and the time for insertion/deletion of a chain with k edges is O(log n + k), all worst-case. The technique is conceptually a special case of the chain method of Lee and Preparata and uses the same query algorithm. The emergence of full dynamic capabilities is afforded by a subtle choice of the chain set (separators), which induces a total order on the set of regions of the planar subdivision.

As most important applications today are large-scale in nature, high-performance methods are becoming indispensable. Two promising computational paradigms for large-scale applications are dynamic and I/O-efficient computations. We give efficient dynamic data structures for several fundamental problems in computational geometry, including point location, ray shooting, shortest path, and minimum-link path. We also develop a collection of new techniques for designing and analyzing I/O-efficient algorithms for graph problems, and illustrate how these techniques can be applied to a wide variety of specific problems, including list ranking, Euler tour, expression-tree evaluation, least-common ancestors, connected and biconnected components, minimum spanning forest, ear decomposition, topological sorting, reachability, graph drawing, and visibility representation. Finally, we present an extensive experimental study comparing the practical I/O efficiency of four algorithms for the orthogonal s...

We present a fully dynamic data structure for point location in a monotone subdivision, based on the trapezoid method. The operations supported are insertion and deletion of vertices and edges, and horizontal translation of vertices. Let n be the current number of vertices of the subdivision. Point location queries take O(logn) time, while updates take O(log² n) time (amortized for vertex insertion/deletion and worst-case for the others). The space requirement is O(n log n). This is the first fully dynamic point location data structure for monotone subdivisions that achieves optimal query time.

Fractional cascading is a technique designed to allow efficient sequential search in a graph with catalogs of total size n. The search consists of locating a key in the catalogs along a path. In this paper we show how to preprocess a variety of fractional cascaded data structures whose underlying graph is a tree so that searching can be done efficiently in parallel. The preprocessing takes O(log n) time with n/log n processors on an EREW PRAM. For a balanced binary tree cooperative search along root-to-leaf paths can be done in O((logn)/logp) time using p processors on a CREW PRAM.

Execution replay is a debugging strategy where a program is run over and over on an input that manifests bugs. For explicitly parallel shared-memory programs, execution replay requires support of special tools --- because these programs can be nondeterministic, their executions can differ from run to run on the same input. For such programs, executions must be traced before they can be replayed for debugging. We present improvements over our past work on an adaptive tracing strategy that records only a fraction of the execution'sshared-memory references. Our past approach makes run-time tracing decisions by detecting and tracing exactly the non-transitive dynamic data dependences among the execution'sshared data. Tracing the non-transitive dependences provides sufficient information for a replay.Inthis paper we show that tracing exactly these dependences is not necessary.Instead, we present two algorithms that introduce and trace artificial dependences among some events that are actually independent. These artificial dependences reduce trace size, but introduce additional event orderings that can reduce the amount of parallelism achievable during replay.Wepresent one algorithm that always adds dependences guaranteed not to be on the critical path and thus do not slow replay.Another algorithm adds as many dependences as possible, slowing replay but reducing trace size further.Experiments show that we can improve the already high trace reduction of our past technique by up to two more orders of magnitude, without slowing replay.Our new techniques usually trace only 0.00025-0.2% of the shared-memory references, a 3-6 order of magnitude reduction over past techniques which trace every access. Copyright 1993 Robert H.B. Netzer. May 31, 1993 1.

INTRODUCTION Randomized algorithms often turn out to be simpler and faster than their deterministic counterparts. For certain problems, like primality testing, there is no matching polynomial-time deterministic algorithm, so the randomized algorithms are the only practical alternative. The above mentioned advantages are sometimes viewed with skepticism because of the inherent uncertainty in the behavior of the randomized algorithm. The uncertainty may be with regards to the correctness (Monte Carlo), or the variation in running time ( Las Vegas). In this chapter we will focus on Las Vegas randomized algorithms that always produce the correct answer, but manifest some variation in the running times. The Present address: Department of Computing and Mathematical Sciences, Chalmers University of Technology and Goteborg University, Goteborg, Sweden. 1 2 most common measure is the expected running time of the algorithm, where the expect

We present a new technique to display a scene of three-dimensional isothetic parallelepipeds (3D-rectangles), viewed from infinity along one of the coordinate axes (axial view). In this situation, there always exists a topological sorting of the 3D-rectangles based on the relation of occlusion (a dominance relation). The arising total order is used to generate the axial view, where the twodimensional view of each 3D-rectangle is incrementally added, starting from the closest 3D-rectangle. The proposed scene-sensitiue algorithm runs in time O(N logzN + d log N), where N is the number of 3D-rectangles and d is the number of edges of the display. This improves over the previously best known technique based on the same approach.