dc.description.abstract 
Parallel algorithms to solve several computational geometric problems on meshconnected computers (MCC's) and systolic arrays are designed and analyzed. We present parallel MCC algorithms to solve the following proximity problems. Given a set of n planar points represented by their Cartesian coordinates, determine the nearest neighbor for each point and find the closest pair of the set. Our algorithms execute on a $\sqrt{n}\times\sqrt{n}$ MCC with constant storage per processor and the time performance is $O(\sqrt{n})$ which is optimal. We also describe parallel algorithm to construct the Voronoi diagram and the minimum spanning tree of a given set of n planar points, and to find the closest pair between two sets on a $\sqrt{n}\times\sqrt{n}$ MCC in $O(\sqrt{n}{\rm log}n)$ time. The best known sequential algorithms for these problems have an optimal $O(n{\rm log}n)$ time complexity.
In addition, MCC algorithms for computing several properties of a set of, possibly intersecting rectangles are presented. Given a set of n isooriented rectangles, we describe MCC algorithms for determining the area of the logic "OR" of these rectangles, the area of pairwise logic "AND" of the rectangles, the largest number of rectangles that overlap and the minimum separation between any pair of a set of nonoverlapping rectangles. All these algorithms can be implemented on a $\sqrt{n}\times\sqrt{n}$ MCC in an optimal $O(\sqrt{n})$ time, and compare favorably with the known sequential algorithms which have $O(n{\rm log}n)$ time complexity.
For the above tasks, we also describe methods to solve problems of size n on MCC's with p processors, where $p < n$. Lower bounds on the time complexity are demonstrated and the optimal size of MCC's to be used is derived.
Finally, we present systolic algorithms to solve the segment intersection counting problem and to construct the convex hull of a set of planar points, as well as an update algorithm for the fixed size circle placement problem. For a problem of size n, our algorithms use a systolic array of $n\sp{2/3}\times n\sp{2/3}$ cells and have a time complexity of $O(n\sp{2/3})$.
