The main contribution of this work is to show that a number of fundamental and seemingly unrelated problems in database design, pattern recognition, robotics, computational geometry, and image processing can be solved simply and elegantly by stating them as instances of a unifying algorithmic framework that we call the multiple query problem. The multiple query problem (MQ, for short) is a 5-tuple (Q, A, D, /spl phi/, /spl oplus/), where Q is a set of queries, A is a set of items, D is a set of solutions, /spl phi/: Q/spl times/A/spl rarr/D is a function, and /spl oplus/ is a commutative and associative binary operator over D. The input to the MQ problem consists of a sequence Q=of m queries from Q and of a sequence A=of n items from A. The goal is to compute, for every query q/sub i/ (1/spl les/i/spl les/m) its solution defined as /spl phi/(q/sub i/,A)=/spl phi/(q/sub i/,a/sub 1/)/spl oplus//spl phi/(q/sub i/,a/sub 2/)/spl oplus//spl middot//spl middot//spl middot//spl oplus//spl phi/(q/sub i/,a/sub n/). We begin by discussing a generic algorithm that solves a large class of MQ problems in O(/spl radic/m+f(n)) time on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n, where f(n) is the time necessary to compute the expression d/sub 1/ /spl oplus/ d/sub 2/ /spl oplus//spl middot//spl middot//spl middot//spl oplus/ d/sub n/ with d/sub i/ /spl isin/ D on such a platform. We then go on to show that the MQ framework affords us an optimal algorithm for the multiple point location problem on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n. Given a set A of n points and a set Q of m (m/spl les/n) points in the plane, our algorithm reports, in O(/spl radic/m+log log n) time, all points of Q that lie inside the convex hull of A. Quite surprisingly, our algorithm solves the multiple point location problem without computing the convex hull of A which, in itself, takes /spl Omega/(/spl radic/n) time on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n. Finally, we prove an /spl Omega/(/spl radic/m+g(n)) time lower bound for nontrivial MQ problems, where g(n) is the lower bound for evaluating the expression d/sub 1/ /spl oplus/ d/sub 2/ /spl oplus//spl middot//spl middot//spl middot//spl oplus/ d/sub n/ with d/sub i/ /spl isin/ D, on a reconfigurable mesh of size /spl radic/n/spl times//spl radic/n.

A number of applications in computer-aided manufacturing, CAD, and computer-aided geometric design ask for triangulating pieces of material with defects. These tasks are known collectively as constrained triangulations. Recently, a powerful architecture called the reconfigurable mesh has been proposed: In essence, a reconfigurable mesh consists of a mesh-connected architecture augmented by a dynamically reconfigurable bus system. The main contribution of this paper is to show that the flexibility of the reconfigurable mesh can be exploited for the purpose of obtaining constant-time algorithms for a number of constrained triangulation problems. These include triangulating a convex planar region containing any constant number of convex holes, triangulating a convex planar region in the presence of a collection of rectangular holes, and triangulating a set of ordered line segments. Specifically with a collection of O(n) such objects as input, our algorithms run in O(1) time on a reconfigurable mesh of size n/spl times/n. To the best of our knowledge, this is the first time constant time solutions to constrained triangulations are reported on this architecture.

The main contribution of this paper is to present simple and elegant podality-based algorithms for a variety of computational tasks motivated by, and finding applications to, pattern recognition, computer graphics, computational morphology, image processing, robotics, computer vision, and VLSI design. The problems that we address involve computing the convex hull, the diameter, the width, and the smallest area enclosing rectangle of a set of points in the plane, as well as the problems of finding the maximum Euclidian distance between two planar sets of points, and of constructing the Minkowski sum of two convex polygons. Specifically, we show that once we fix a positive constant /spl epsiv/, all instances of size m, (n/sup 1/2 +/spl epsiv///spl les/m/spl les/n) of the problems above, stored in the first [m//spl radic/n] columns of a mesh with multiple broadcasting of size /spl radic/n/spl times//spl radic/n can be solved time-optimally in /spl Theta/(m//spl radic/n) time.

Query processing is a crucial component of various application domains including information retrieval, database design and management, pattern recognition, robotics, and VLSI. Many of these applications involve data stored in a matrix satisfying a number of properties. One property that occurs time and again specifies that the rows and the columns of the matrix are independently sorted. It is customary to refer to such a matrix as sorted. An instance of the batched searching and ranking problem (BSR) involves a sorted matrix A of items from a totally ordered universe, along with a collection Q of queries. Q is an arbitrary mix of the following query types: for a search query q/sub j/, one is interested in an item of A that is closest to q/sub j/; for a rank query q/sub j/ one is interested in the number of items of A that are strictly smaller than q/sub j/. The BSR problem asks for solving all queries in Q. The authors consider the BSR problem in the following context: the matrix A is pretiled, one item per processor, onto an enhanced mesh of size /spl radic/n/spl times//spl radic/n; the m queries are stored, one per processor, in the first m//spl radic/n~ columns of the platform. Their main contribution is twofold. First, they show that any algorithm that solves the BSR problem must take at least /spl Omega/(max{logn, /spl radic/m}) time in the worst case. Second, they show that this time lower bound is tight on meshes of size /spl radic/n/spl times//spl radic/n enhanced with multiple broadcasting, by exhibiting an algorithm solving the BSR problem in /spl Theta/(max{logn, /spl radic/m}) time on such a platform.

Answering rank queries is a recurring operation in various application domains including geographic data processing, information retrieval, database design, information management, and medical image processing. Many of these applications involve data stored in a matrix satisfying a number of properties. One property that occurs time and again in applications specifies that the rows and the columns of the matrix are independently sorted. It is customary to refer to such a matrix as sorted. An instance of the Batched Ranking problem, (BR, for short) involves a sorted matrix A of items from a totally ordered universe, along with a collection Q of queries of the following type: for a query q/sub j/ one is interested in the number of items in A that are smaller than q/sub j/. The BR problem asks for solving all queries in Q. In this work, we consider the BR problem in the following context: the matrix A is pretiled, one item per processor, onto an enhanced mesh of size /spl radic/n/spl times//spl radic/n; the m queries are stored, one per processor, in the first m//spl radic/n columns of the platform. Our main contribution is twofold. First, we show that any algorithm that solves the BR problem must take at least /spl Omega/(log n+/spl radic/m) time in the worst case. Second, we show that this time lower bound is tight on meshes of size /spl radic/n/spl times//spl radic/n enhanced with multiple broadcasting, by exhibiting an algorithm solving the BR problem in O(log n+/spl radic/m) time on such a platform.

The main contribution of this work is to show that a number of digital geometry problems can be solved elegantly on meshes with multiple broadcasting by using a time-optimal solution to the leftmost one problem as a basic subroutine. Consider a binary image pretiled onto a mesh with multiple broadcasting of size [Formula: see text] one pixel per processor. Our first contribution is to prove an Ω(n1/6) time lower bound for the problem of deciding whether the image contains at least one black pixel. We then obtain time lower bounds for many other digital geometry problems by reducing this fundamental problem to all the other problems of interest. Specifically, the problems that we address are: detecting whether an image contains at least one black pixel, computing the convex hull of the image, computing the diameter of an image, deciding whether a set of digital points is a digital line, computing the minimum distance between two images, deciding whether two images are linearly separable, computing the perimeter, area and width of a given image. Our second contribution is to show that the time lower bounds obtained are tight by exhibiting simple O(n1/6) time algorithms for these problems. As previously mentioned, an interesting feature of these algorithms is that they use, directly or indirectly, an algorithm for the leftmost one problem recently developed by one of the authors.

Given a collection of objects in the plane along with a viewpoint /spl omega/, the visibility problem involves determining the portion of each object that is visible to an observer positioned at /spl omega/. The visibility problem is central to various application areas including computer graphics, image processing, VLSI design, and robot navigation, among many others. The main contribution of this work is to provide time-optimal solutions to this problem for several classes of objects, namely ordered line segments, disks, and iso-oriented rectangles in the plane. In addition, our visibility algorithm for line segments is at the heart of time-optimal solutions for determining, for each element in a given sequence of real numbers, the position of the nearest larger element within that sequence, triangulating a set of points in the plane, determining the visibility pairs among a set of vertical line segments, and constructing the dominance and visibility graphs of a set of iso-oriented rectangles in the plane. All the algorithms in this paper involve an input of size n and run in O(log n) time on a mesh with multiple broadcasting of size n/spl times/n. This is the first instance of time-optimal solutions for these problems on this architecture.>

Triangulating a set of points in the plane is a central theme in computer-aided manufacturing, robotics, CAD, VLSI design, geographic data processing, and computer graphics. Even more challenging are constrained triangulations, where a triangulation is sought in the presence of a number of constraints such as prescribed edges and/or forbidden areas. In this paper, we show that the flexibility of the reconfigurable mesh architecture can be exploited to obtain constant-time algorithms for a number of triangulation problems. These include triangulating an arbitrary set of points in the plane, a convex planar region with a convex hole, and a convex planar region in the presence of rectangular holes. Specifically, with a collection of O(n) such constraints as input, our algorithms run in O(1) time on a reconfigurable mesh of size n/spl times/n. To the best of our knowledge, these are the first constant time solutions to constrained triangulations reported on this architecture.>

Consider arbitrary collections A = a_1,a_2,.. .,a_n of items and Q = q_1,q_2,...,q_m (1 leqslant mn leqslant n) of queries from a totally ordered universe. The multiple rank problem involves computing for every query qi the number of items in A that have a lesser value. Our contribution is to show that the problem at hand can be solved time-optimally on meshes with multiple broadcasting. More specifically, if the collection A is siored in some order one item per processor and if Q is stored one query per processor in the leftmost frac{m} {{sqrt n }} columns of a mesh with multiple broadcasting of size sqrt n x /sqrt n, the corresponding instance of the multiple rank problem can be solved in Theta left( {m^{frac{1} {3}} n^{frac{1} {6}} } right) time. As an application we present a time-optimal algorithm to compute the histogram of a m-level gray image of size sqrt n x sqrt n in Theta left( {m^{frac{1} {3}} n^{frac{1} {6}} } right) time.

Recently the authors have shown that the versatility of the reconfigurable mesh can be exploited to devise 0(1) time algorithms for a number of important computational tasks relevant to image processing, computer graphics, and computer vision. Specifically, we have shown that if one or two n-vertex (convex) polygons are pretiled, one vertex per processor, onto a reconfigurable mesh of size sqrt n X sqrt n, then a number of geometric problems can be solved in 0(1) time. These include testing an arbitrary polygon for convexity, the point location problem, the supporting lines problem, the stabbing problem, constructing the common tangents of two separable convex polygons, deciding whether two convex polygons intersect, and computing the smallest distance between the boundaries of two convex polygons. The novelty of these algorithms is that the problems are solved in the dense case. The purpose of this paper is to add to the list of problems that can be solved in 0(1) time in the dense case. The problems that we address are: determining the minimum area corner triangle for a convex polygon, determining the k-maximal vertices of a restricted class of convex polygons, updating the convex hull of a convex polygon in the presence of a set of query points, and determining a point that belongs to exactly one of two given convex polygons.

The compaction step of integrated circuit design motivates the study of various visibility problems among vertical segments in the plane. One popular variant is referred to as the Vertical Segment Visibility problem (VSV, for short) and is stated as follows. Given a collection S of n disjoint vertical line segments in the plane, for every endpoint of a segment in S determine the first line segment, if any, interacted by a horizontal ray to the right (resp. left) originating from that endpoint. The contribution of this paper is to propose a time-optimal algorithm for the VSP problem on meshes with multiple broadcasting. The authors then use this algorithm to derive time-optimal solutions for two related problems. All the algorithms run in O(log n) time on a mesh with multiple broadcasting of size n /spl times/ n. This is the first instance of time-optimal solutions for these problems known to us.>