Showing papers by "Michael T. Goodrich published in 1999"

Communication-Efficient Parallel Sorting

Abstract: We study the problem of sorting n numbers on a p-processor bulk-synchronous parallel (BSP) computer, which is a parallel multicomputer that allows for general processor-to-processor communication rounds provided each processor sends and receives at most h items in any round. We provide parallel sorting methods that use internal computation time that is $O({n\log n \over p})$ and a number of communication rounds that is $O({\log n \over \log (h+1)})$ for $h=\Theta(n/p)$. The internal computation bound is optimal for any comparison-based sorting algorithm. Moreover, the number of communication rounds is bounded by a constant for the (practical) situations when $p\le n^{1-{1/c}}$ for a constant $c\ge 1$. In fact, we show that our bound on the number of communication rounds is asymptotically optimal for the full range of values for p, for we show that just computing the "or" of n bits distributed evenly to the first O(n/h) of an arbitrary number of processors in a BSP computer requires $\Omega(\log n/\log (h+1))$ communication rounds.

Balanced aspect ratio trees: combining the advantages of k-d trees and octrees

Abstract: Given a set S of n points on Rd, we show, for fixed d, how to construct in O(nlogn) time a data structure we call the balanced aspect ratio (BAR) tree. A BAR tree is a binary space partition tree on S that has O(logn) depth in which every region is convex and “fat” (that is, has a bounded aspect ratio). While previous hierarchical data structures such as k-d trees, quadtrees, octrees, fair-split trees, and balanced box decompositions can guarantee some of these properties, we know of no previous data structure that combines all of these properties simultaneously. The BAR tree data structure has numerous applications ranging from geometric searching problems in fixed dimensional space to the visualization of graphs and three-dimensional worlds.

Approximate geometric pattern matching under rigid motions

Abstract: We present techniques for matching point-sets in two and three dimensions under rigid-body transformations. We prove bounds on the worst-case performance of these algorithms to be within a small constant factor of optimal and conduct experiments to show that the average performance of these matching algorithms is often better than that predicted by the worst-case bounds.

Dynamic Trees and Dynamic Point Location

Abstract: This paper describes new methods for maintaining a point-location data structure for a dynamically changing monotone subdivision $\cal S$. The main approach is based on the maintenance of two interlaced spanning trees, one for $\cal S$ and one for the graph-theoretic planar dual of $\cal 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 [J. Comput. System Sci., 26 (1983), pp. 362--381], 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(log2 n) time, with O(n) space, where n is the current size of subdivision $\cal 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 location (where one builds $\cal S$ incrementally), improving the query bound to $O(\log n\log\log n)$ time and the update bounds to O(1)amortized time in this case. This appears to be the first on-line method to achieve a polylogarithmic query time and constant update time.

Testers and visualizers for teaching data structures

Abstract: We present two tools to support the teaching of data structures and algorithms: Visualizers, which provide interactive visualizations of user-written data structures, and Testers, which check the functionality of user-written data structures. We outline a prototype implementation of visualizers and testers for data structures written in Java, and report on classroom use of testers and visualizers in an introductory Data Structures and Algorithms (CS2) course.

Drawing Planar Graphs with Circular Arcs

Abstract: In this paper we address the problem of drawing planar graphs with circular arcs while maintaining good angular resolution and small drawing area. We present a lower bound on the area of drawings in which edges are drawn using exactly one circular arc. We also give an algorithm for drawing n-vertex planar graphs such that the edges are sequences of two continuous circular arcs. The algorithm runs in O(n) time and embeds the graph on the O(n) × O(n) grid, while maintaining θ(1/d(v)) angular resolution, where d(v) is the degree of vertex v. Since in this case we use circular arcs of infinite radius, this is also the first algorithm to simultaneously achieve good angular resolution, small area and at most one bend per edge using straight-line segments. Finally, we show how to create drawings in which edges are smooth C1-continuous curves, represented by a sequence of at most three circular arcs.

Efficient perspective-accurate silhouette computation

Abstract: Silhouettes of geometric models (see Fig.1) are salient for many applications, including visualization [LE97] and shape analysis [BV95, Cro77]. The video describes a technique for efficient tracking of perspective-accurate silhouettes by reducing the problem to point location queries. Perspective-accurate silhouette computation is known to be difficult [KM96, KM98, KMGL96]. Note that silhouettes formed under perspective projection are significantly different from those under parallel projection and are more difficult to compute. Given a polyhedral model with well-defined normals, the polygons (facets) whose normals point away from the viewpoint are called back-facing. Similarly, normals of front-facing polygons point toward the viewpoint. An edge shared by a back-facing polygon and a front-facing polygon is said to be on the silhouette of the model. The silhouette of a geometric model is among its most significant visual features. It may be used to describe the shape of a model with only very few details of its geometry. It can also be used for computing the visible portions of a model as it forms the boundary between the visible front-facing and the hidden back-facing polygons. Silhouettes are also useful in shadow generation [Cro77], model simplification [LE97], collision detection [BV95], image registration [LSB95], and several other applications. The video presents an incremental algorithm for computing silhouettes of polyhedral models and updating them as the viewpoint changes. Most applications of interest exhibit coherence in silhouettes between successive computations as viewpoints change slowly. Our algorithm exploits this coherence to obtain fast updates of the silhouettes. Assume that we know the silhouette of a model from .a given view point. An edge ceases to be (resp., becomes) a silhouette edge if and only if it is shared by one front-facing and one back-facing polygon (resp., two polygons of the same facing), and exactly one of its adjacent polygons changes orientation. Thus, when the viewpoint is changed we are interested in finding such orientation-change events. We reduce this problem to a point-location query in a planar-map data structure.

Planarity-Preserving Clustering and Embedding for Large Planar Graphs

Abstract: In this paper we present a novel approach for cluster-based drawing of large planar graphs that maintains planarity. Our technique works for arbitrary planar graphs and produces a clustering which satisfies the conditions for compound-planarity (c-planarity). Using the clustering, we obtain a representation of the graph as a collection of O(log n) layers, where each succeeding layer represents the graph in an increasing level of detail. At the same time, the difference between two graphs on neighboring layers of the hierarchy is small, thus preserving the viewer’s mental map. The overall running time of the algorithm is O(n log n), where n is the number of vertices of graph G.

Tiered Vectors: Efficient Dynamic Arrays for Rank-Based Sequences

Abstract: We describe a data structure, the tiered vector, which is an implementation of the Vector ADT that provides O(1-Ɛ) worst case time performance for rank-based retrieval and O(nƐ) amortized time peroformance for rank-based insertion and deletion, for any fixed Ɛ > 0. We also provide results from experiments involving the use of the tiered vector for Ɛ = 1=2 in JDSL, the Data Structures Library in Java.

GeomNet: geometric computing over the Internet

Abstract: Geometric computing has become a central building block in fields like computer graphics, artificial intelligence, CAD and GIS databases. The paper discusses the GeomNet system. GeomNet's layered client-server architecture lets users perform distributed geometric computing over the Internet without having to download, install, and interface with application-specific software.

Accessing the Internal Organization of Data Structures in the JDSL Library

Abstract: Many applications require data structures that allow efficient access to their internal organization and to their elements. This feature has been implemented in some libraries with iterators or items. We present an alternative implementation, used in the Library of Data Structures for Java (JDSL). We refine the notion of an item and split it into two related concepts: position and locator. Positions are an abstraction of a pointer to a node or an index into an array; they provide direct access to the in-memory structure of the container. Locators add a level of indirection and allow the user to find a specific element even if the position holding the element changes.

Using randomization in the teaching of data structures and algorithms

Abstract: We describe an approach for incorporating randomization in the teaching of data structures and algorithms. The proofs we include are quite simple and can easily be made a part of a Freshman-Sophomore Introduction to Data Structures (CS2) course and a Junior-Senior level course on the design and analysis of data structures and algorithms (CS7/DS&A). The main idea of this approach is to show that using randomization in data structures and algorithms is safe and can be used to significantly simplify efficient solutions to various computational problems. We illustrate this approach by giving examples of the use of randomization in some traditional topics from CS2 and DS&A.

Algorithm Engineering and Experimentation: International Workshop ALENEX'99 Baltimore, MD, USA, January 15-16, 1999, Selected Papers

Abstract: Combinatorial Algorithms.- Efficient Implementation of the WARM-UP Algorithm for the Construction of Length-Restricted Prefix Codes.- Implementing Weighted b-Matching Algorithms: Insights from a Computational Study.- Designing Practical Efficient Algorithms for Symmetric Multiprocessors.- Circular Drawings of Biconnected Graphs.- Heuristics and Experimental Design for Bigraph Crossing Number Minimization.- Binary Space Parititions in Plucker Space.- Practical Point-in-Polygon Tests Using CSG Representations of Polygons.- Software and Applications.- Accessing the Internal Organization of Data Structures in the JDSL Library.- Object-Oriented Design of Graph Oriented Data Structures.- A Case Study on the Cost of Geometric Computing.- Design and Implementation of the Fiduccia-Mattheyses Heuristic for VLSI Netlist Partitioning.- Algorithms for Restoration Planning in a Telecommunications Network.- Computing the n x m Shortest Paths Efficiently.- Image Watermarking for Copyright Protection.- Algorithms for NP-Hard Problems.- A Self Organizing Bin Packing Heuristic.- Finding the Right Cutting Planes for the TSP.- Obstacle-Avoiding Euclidean Steiner Trees in the Plane: An Exact Algorithm.- Data Structures.- Adaptive Algorithms for Cache-efficient Trie Search.- Fast Priority Queues for Cached Memory.- Efficient Bulk Operations on Dynamic R-trees.

Algorithm Engineering and Experimentation

Abstract: Given an alphabet Σ = {a1, . . . , an} with a corresponding list of positive weights {w1, . . . , wn} and a length restriction L, the length-restricted prefix code problem is to find, a prefix code that minimizes ∑n i=1 wili, where li, the length of the codeword assigned to ai, cannot be greater than L, for i = 1, . . . , n. In this paper, we present an efficient implementation of the WARM-UP algorithm, an approximative method for this problem. The worst-case time complexity of WARM-UP is O(n log n + n log wn), where wn is the greatest weight. However, some experiments with a previous implementation of WARM-UP show that it runs in linear time for several practical cases, if the input weights are already sorted. In addition, it often produces optimal codes. The proposed implementation combines two new enhancements to reduce the space usage of WARM-UP and to improve its execution time. As a result, it is about ten times faster than the previous implementation of WARM-UP and overcomes the LRR Package Method, the faster known exact method.