Biing-Feng Wang

Constant time algorithms for the transitive closure and some related graph problems on processor arrays with reconfigurable bus systems

The transitive closure problem in O(1) time is solved by a new method that is far different from the conventional solution method. On processor arrays with reconfigurable bus systems, two O(1) time algorithms are proposed for computing the transitive closure of an undirected graph. One is designed on a three-dimensional n*n*n processor array with a reconfigurable bus system, and the other is designed on a two-dimensional n/sup 2/*n/sup 2/ processor array with a reconfigurable bus system, where n is the number of vertices in the graph. Using the O(1) time transitive closure algorithms, many other graph problems are solved in O(1) time. These problems include recognizing bipartite graphs and finding connected components, articulation points, biconnected components, bridges, and minimum spanning trees in undirected graphs. >

Two-dimensional processor array with a reconfigurable bus system is at least as powerful as CRCW model

Abstract The power of a computation model usually indicates how fast a problem can be solved under that model. The CRCW shared-memory computer has been considered the most powerful computation model. Recently, the two-dimensional processor array with a reconfigurable bus system (such as the reconfigurable mesh and the polymorphic-torus network) has been proposed for solving many problems efficiently. Since the structure of the two-dimensional processor array with a reconfigurable bus system is regular, it is suitable for VLSI implementation. In this paper, we show that the two-dimensional processor array with a reconfigurable bus system is at least as powerful as the CRCW shared-memory computer. To say more concretely, we show that if a problem can be solved in O( f ( n )) time on the CRCW shared-memory computer, it can also be solved in O( f ( n )) time on the two-dimensional processor array with a reconfigurable bus system. Also, the proof suggests a general method to convert algorithms designed on the former into algorithms on the latter.

Linear time algorithms for the ring loading problem with demand splitting

Given a ring of size n and a set K of traffic demands, the ring loading problem with demand splitting (RLPW) is to determine a routing to minimize the maximum load on the edges. In the problem, a demand between two nodes can be split into two flows and then be routed along the ring in different directions. If the two flows obtained by splitting a demand are restricted to integers, this restricted version is called the ring loading problem with integer demand splitting (RLPWI). In this paper, efficient algorithms are proposed for the RLPW and the RLPWI. Both the proposed algorithms require O(|K| + ts) time, where ts is the time for sorting |K| nodes. If |K| ≥ ne for some small constant e > 0, integer sort can be applied and thus ts = O(|K|); otherwise, ts = O(|K| log |K|). For real world applications, |K| is usually not smaller than n and thus our algorithms achieve linear time. The proposed algorithms improve the previous upper bounds from O(min{n|K|, n2}) for RLPW and from O(n|K|) for RLPWI.

Efficient Parallel Algorithms for Optimally Locating a Path and a Tree of a Specified Length in a Weighted Tree Network

In this paper, we propose efficient parallel algorithms on the EREW PRAM for optimally locating in a tree network a path-shaped facility and a tree-shaped facility of a specified length. Edges in the tree network have arbitrary positive lengths. Two optimization criteria are considered: minimum eccentricity and minimum distancesum. Let n be the number of vertices in the tree network. Our algorithm for finding a minimum eccentricity location of a path-shaped facility takes O(logn) time using O(n) work. Our algorithm for finding a minimum distancesum location of a path-shaped facility takes O(logn) time using O(n2) work. Both of our algorithms for finding the minimum eccentricity location and a minimum distancesum location of a tree-shaped facility take O(lognloglogn) time using O(n) work. In the sequential case, all the proposed algorithms are faster than those previously proposed by Minieka. Recently, Peng and Lo have proposed parallel algorithms for all the four problems considered in this paper. They assumed that each edge in the tree network is of length 1. Thus, as compared with their algorithms ours are more general. Besides, our algorithms for the problems of finding a minimum eccentricity location of a path-shaped facility, the minimum eccentricity location of a tree-shaped facility, and a minimum distancesum location of a tree-shaped facility are more efficient from the aspect of work. Their algorithms for these three problems use O(nlogn) work. Ours use O(n) work.

On the parallel computation of the algebraic path problem

The algebraic path problem is a general description of a class of problems, including some important graph problems such as transitive closure, all pairs shortest paths, minimum spanning tree, etc. In this work, the algebraic path problem is solved on a processor array with a reconfigurable bus system. The proposed algorithms are based on repeated matrix multiplications. The multiplication of two n*n matrices takes O(log n) time in the worst case, but, for some special cases, O(1) time is possible. It is shown that three instances of the algebraic path problem, transitive closure, all pairs shortest paths, and minimum spanning tree, can be solved in O(log n) time, which is as fast as on the CRCW PRAM. >

Improved algorithms for the minmax-regret 1-center and 1-median problems

In this article, efficient algorithms are presented for the minmax-regret 1-center and 1-median problems on a general graph and a tree with uncertain vertex weights. For the minmax-regret 1-center problem on a general graph, we improve the previous upper bound from <i>O</i>(<i>mn</i>² log <i>n</i>) to <i>O</i>(<i>mn</i> log <i>n</i>). For the problem on a tree, we improve the upper bound from <i>O</i>(<i>n</i>²) to <i>O</i>(<i>n</i> log² <i>n</i>). For the minmax-regret 1-median problem on a general graph, we improve the upper bound from <i>O</i>(<i>mn</i>² log <i>n</i>) to <i>O</i>(<i>mn</i>² + <i>n</i>³ log <i>n</i>). For the problem on a tree, we improve the upper bound from <i>O</i>(<i>n</i> log² <i>n</i>) to <i>O</i>(<i>n</i> log <i>n</i>).

Finding a k-tree core and a k-tree center of a tree network in parallel

A k-tree core of a tree network is a subtree with exactly k leaves that minimizes the total distance from vertices to the subtree. A k-tree center of a tree network is a subtree with exactly k leaves that minimizes the distance from the farthest vertex to the subtree. In this paper, two efficient parallel algorithms are proposed for finding a k-tree core and a k-tree center of a tree network, respectively. Both the proposed algorithms perform on the EREW PRAM in O(log n log n) time using O(n) work (time-processor product). Besides being efficient on the EREW PRAM, in the sequential case, our algorithm for finding a k-tree core of a tree network improves the two algorithms previously proposed.

The mesh with hybrid buses: an efficient parallel architecture for digital geometry

The first main contribution of this work is to propose an efficient VLSI architecture obtained by augmenting the Mesh with Multiple Broadcasting (MMB) with precharged 1-bit row and column buses. The new architecture, which we call Mesh with Hybrid Buses (MHB for short), is realizable in VLSI with no increase in the area or the wiring complexity of the MMB chip. Our second main contribution is to show that the MHB is extremely well-suited for solving an entire slew of digital geometry tasks. The MHB is not a reconfigurable architecture. Yet, quite remarkably, for a large number of fundamental digital geometry tasks, the MHB offers a level of performance previously attained only by reconfigurable architectures. Specifically, with a digital image pretiled onto a MHB of size /spl radic/n/spl times//spl radic/n one pixel per processor, we show that the problems of computing the convex hull of the image, computing the diameter and the width of the image, deciding whether a set of digital points is a digital line, computing the maximum distance between two images, deciding whether two images are linearly separable, computing several moments and low-level descriptors of the image, including the perimeter, area, center, and median row of its convex hull, can be solved in O(log n) time. By contrast, the fastest possible algorithms for the problems above on the MMB run in /spl Theta/(n/sup 1/6/) time. Finally, we go on to show that, with minor changes, our algorithms can be implemented to run within cost-optimality on a MHB of size /spl radic/n/log n/spl times//spl radic/n/log n.

Sorting and computing convex hulls on processor arrays with reconfigurable bus systems

A reconfigurable bus system is a bus system whose configuration is dynamically changeable. In this paper, using configurational computation, we show that the problems of sorting and computing convex hulls can be solved in O(1) time on two-dimensional (n ∗ m) × (n∗[nm]) processor arrays with reconfigurable bus systems, where n is the problem size and m is any integer between 1 and n.

Cost-optimal parallel algorithms for the tree bisector and related problems

An edge is a bisector of a simple path if it contains the middle point of the path. Let T=(V,E) be a tree. Given a source vertex s /spl isin/ V, the single-source tree bisector problem is to find, for every vertex /spl upsi/ /spl isin/ V, a bisector of the simple path from s to /spl upsi/. The all-pairs tree bisector problem is to find for, every pair of vertices u, /spl upsi/ /spl isin/ V, a bisector of the simple path from u to /spl upsi/. In this paper, it is first shown that solving the single-source tree bisector problem of a weighted tree has a time lower bound /spl Omega/(n log n) in the sequential case. Then, efficient parallel algorithms are proposed on the EREW PRAM for the single-source and all-pairs tree bisector problems. Two O(log n) time single-source algorithms are proposed. One uses O(n) work and is for unweighted trees. The other uses O(n log n) work and is for weighted trees. Previous algorithms for the single-source problem could achieve the same time O(log n) and the same optimal work, O(n) for unweighted trees and O(n log n) for weighted trees, on the CRCW PRAM. The contribution of our single-source algorithms is the improvement from CRCW to EREW. One all-pairs parallel algorithm is proposed. It requires O(log n) time using O(n/sup 2/) work. All the proposed algorithms are cost-optimal. Efficient tree bisector algorithms have practical applications to several location problems on trees. Using the proposed algorithms, efficient parallel solutions for those problems are also presented.