Showing papers by "Ming-Yang Kao published in 1993"

Searching in an unknown environment: an optimal randomized algorithm for the cow-path problem

Abstract: Searching for a goal is a central and extensively studied problem in computer science. In classical searching problems, the cost of a search function is simply the number of queries made to an oracle that knows the position of the goal. In many robotics problems, as well as in problems from other areas, we want to charge a cost proportional to the distance between queries (e.g., the time required to travel between two query points). With this cost function in mind, the abstract problem known as the $w$-lane cow-path problem was designed. There are known optimal deterministic algorithms for the cow-path problem, and we give the first randomized algorithms in this paper. We show that our algorithm is optimal for two paths ($w=2$), and give evidence that it is indeed optimal for larger values of $w$. The randomized algorithms give expected performance that is almost twice as good as is possible with a deterministic algorithm.

Scan-first search and sparse certificates: an improved parallel algorithm for k -vertex connectivity

Abstract: Given a graph $G = (V,E)$, a certificate of k-vertex connectivity is an edge subset $E' \subset E$ such that the subgraph $(V,E')$ is k-vertex connected if and only if G is k-vertex connected. Let n and m denote the number of vertices and edges. A certificate is called sparse if it contains $O(kn)$ edges.For undirected graphs, this paper introduces a graph search called the scan-first search, and shows that a certificate with at most $k(n - 1)$ edges can be computed by executing scan-first search k times in sequence on subgraphs of G. For each of the parallel, distributed, and sequential models of computation, the complexity of scan-first search matches the best complexity of any graph search on that model. In particular, the parallel scan-first search runs in $O(\log n)$ time using $C(n,m)$ processors on a CRCW PRAM, where $C(n,m)$ is the number of processors needed to find a spanning tree in each connected component in $O(\log n)$ time, and the parallel certificate algorithm runs in $O(k\log n)$ time us...

Linear-processor NC algorithms for planar directed graphs I: strongly connected components

Abstract: Finding strongly connected components is a fundamental step in many algorithms for directed graphs. In sequential computation this problem has an optimal linear-time algorithm. In parallel computation, however, it remains an open problem whether polylogarithmic time and a linear number of processors are sufficient for computing the strongly connected components on a parallel random-access machine. This paper provides the first nontrivial partial solution to the open problem: for a planar directed graph of size n the strongly connected components can be computed deterministically in $O(\log ^3 n)$ time with ${n / {\log n}}$ processors. The algorithm runs on a parallel random-access machine that allows concurrent reads and concurrent writes in its shared memory and, in case of a write conflict, permits an arbitrary processor to succeed.

Linear-processor NC algorithms for planar directed graphs II: directed spanning trees

Abstract: It has long been a fundamental open problem whether polylog time and {\em linear} processors are sufficient to find the strongly connected components of a directed graph and compute directed spanning trees for these components. This paper provides the first nontrivial partial solution to the tree problem: for a planar directed graph with $n$ vertices, if the graph is strongly connected, then a directed spanning tree rooted at a specified vertex can be built in $0(log^2~n)$ time using $0(n)$ processors. The algorithm is deterministic and runs on a parallel random access machine that allows concurrent reads and concurrent writes in its shared memory. The result complements an algorithm by Kao that computes the strongly connected components of a planar directed graph in $0(log^3~n)$ time and $0(n)$ processors.

Improved Parallel Depth-First Search in Undirected Planar Graphs

Abstract: We present an improved parallel algorithm for constructing a depth-first search tree in a connected undirected planar graph. The algorithm runs in O(log2n) time with n/log n processors for an n-vertex graph. It hinges on the use of a new optimal algorithm for computing a cycle separator of an embedded planar graph in O(log n) time with n/log n processors. The best previous algorithms for computing depth-first search trees and cycle separators achieved the same time complexities, but with n processors. Our algorithms run on a parallel random access machine that permits concurrent reads and concurrent writes in its shared memory and allows an arbitrary processor to succeed in case of a write conflict.