Gen-Huey Chen

Distributed algorithms for the quickest path problem

Let N = (V, A, C, L) be a network with node set V, arc set A, positive arc capacity function C, and nonnegative arc lead time function L. The quickest path problems is to find paths in N to transmit a given amount of data such that the transmission time is minimized. In this paper, distributed algorithms are developed for the quickest path problem in an asynchronous communication network. For the one-source quickest path problem, we present three algorithms that require O(rn2) messages and O(2) time, O(n) messages and O(rn) time, and O1+elog w) messages and O(rn1+elog w) time for any e, 0<e<1, respectively, where m = |A|, n = |V|, r is the number of distinct capacity values of N, and w is the maxima arc weight of N. For the all-pairs quickest path problem, we present an algorithm that requires O(mn) messages and O(m) time.

Pipeline architectures for dynamic programming algorithms

Abstract Dynamic programming is one of the most powerful approaches to many combinatorial optimization problems. In this paper, we present pipeline architectures for the dynamic programming algorithms for the knapsack problems. They enable us to achieve an optimal speedup using processor arrays, queues, and memory modules. The processor arrays can be regarded as pipelines where the dynamic programming algorithms are implemented through pipelining.

Parallel generation of permutations and combinations

In this paper we will present a parallel algorithm to generate the permutations of at mostk out ofn objects. The architecture consists of a linear processor array and a selector. When one single processor array is available, a parallel algorithm to generate permutations is presented which achieves the best possible speedup for any givenk. Also, this algorithm can easily be modified to generate combinations. When multiple processor arrays are available, a parallel scheme is proposed to speed up the generation by fully utilizing these processor arrays. The degree of parallelism is related to the number of available processor arrays.

Systolic algorithms to examine all pairs of elements

Four methods to solve the all pairs examination problem are presented. The first two methods are based on the fold-over scheme. The remaining two methods are adopted from some parallel sorting algorithms. All of these approaches can be implemented on a linear systolic array.

An LC branch-and-branch algorithm for the module assignment problem

Abstract Distributed processing has been a subject of recent interest due to the availability of computer networks. Over the past few years it has lead to the identification of several challenging problems. One of these is the problem of optimally distributing program modules over a distributed processing system. In this paper we present an LC (Leas Cost) branch-and-bound algorithm to find an optimal assignment that minimizes the sum of execution costs and communication costs. Experimental results show that, for over half of the randomly generated instances, the saving rates exceed 99%. Moreover, it appears that the saving rates rise as the size of the instances increases. Finally, we also introduce two reduction rules to improve the efficiency of the algorithm for some special cases.

An improved parallel algorithm for 0/1 knapsack problem

Abstract A parallel algorithm based on a technique called delayed dominance is proposed for solving the 0/1 knapsack problem. This parallel algorithm is a modification of Chen, Chern and Jangs algorithm. Experiments show that the new algorithm has a better performance than Chen et al.s algorithm.

An 0(1) time algorithm for string matching

An 0(1) time algorithm for string matching is designed on a two-dimensional (n-m+1)x n processor array with a reconfigurable bus system, where n and m are the length of text and pattern respectively.

Generate all maximal independent sets in permutation graphs

In this paper, an O(n log n + k) time algorithm is presented to generate all maximal independent sets in a permutation graph, where n is the number of vertices in the graph and k is the number of vertices generated. The space requirement is O(n log n).

The weighted maximum independent set problem in permutation graphs

In this paper, sequential and parallel algorithms are presented to find a maximum independent set with largest weight in a weighted permutation graph. The sequential algorithm, which is designed based on dynamic programming, runs in timeO(nlogn) and requiresO(n) space. The parallel algorithm runs inO(log2n) time usingO(n3/logn) processors on the CREW PRAM, orO(logn) time usingO(n3) processors on the CRCW PRAM.

A new systolic architecture for convex hull and half-plane intersection problems

In this paper we will present systolic algorithms for static versions of the convex hull problem and the half-plane intersection problem. The systolic algorithms are based on a cyclic shift operation that makes each object meet all the other objects.