Breadth-first Search Tree Research Articles

Planar Depth-First Search in $O(\log n)$ Parallel Time

It is shown that, in the PRIORITY CROW PRAM model and for the class of undirected embedded planar graphs, depth-first search (DFS) trees are no more difficult to construct than breadth-first search (BFS) trees. Specifically, suppose that time $T(n)\geqq \log n$ and $p(n)$ processors suffice to construct a planar embedding of a planar graph on n vertices and to compute a BFS tree of an undirected connected planar graph on $3n$ vertices. Then, given an undirected connected planar graph G on n vertices, a DFS tree of G can be computed in the stated model in $O(T(n))$ time with $p(n)$ processors. By using known results for the above problems, a DFS tree construction algorithm that runs in $O(\log n)$ time and uses $O(n^{3})$ processors is derived. The fastest previously known algorithm has time and processor bounds of $O({(\log n)}^2)$ and $O(n)$, respectively.

Recognizing breadth-first search trees in linear time

A linear-time algorithm for the following problem is presented: Given an undirected graph G=( V, E) and a spanning tree T of G, determine whether Tcan be the outcome of a breadth-first search on G, and if so, find all possible roots of the breadth-first search.

An improvement of Goldberg, Plotkin and Vaidya's maximal node-disjoint paths algorithm

Goldberg, Plotkin, and Vaidya recently developed a sublinear-time parallel algorithm for finding maximal node-disjoint paths [3] with the concurrent-read concurrent-write random access machine model (CRCW PRAM) [2] by balancing two approaches to the problem appropriately. We improve their results by finding a better balance factor. Our results are as follows: we can find maximal node-disjoint paths for undirected graphs in O(√ nlog 2 n) time with O( n + m) processors improved from O(√ nlog 3 n) time with the same number of processors; for directed graphs in O(√ nlog 5/2 n) time with BFS( n, m)processors improved from O(√ nlog 3 n) time with the same number of processors. Here BFS( n, m) denotes the maximum of n + m and the number of processors required to find a breadth-first search tree in O(log 2 n) time for a directed graph with n vertices and m edges. As a consequence of our result, we show that a depth-first search tree in an undirected graph can be found in O(√ nlog 5 n) time with O( n + m) processors.

A new distributed algorithm to find breadth first search trees

A new distributed algorithm is presented for constructing breadth first search (BFS) trees. A BFS tree is a tree of shortest paths from a given root node to all other nodes of a network under the assumption of unit edge weights; such trees provide useful building blocks for a number of routing and control functions in communication networks. The order of communication complexity for the new algorithm is O(V^{1.6} + E) where V is the number of nodes and E the number of edges. For dense networks with E \geq V^{1.6} this order of complexity is optimum.

L n norm optimal histogram matching and application to similarity retrieval

The problem of optimal histogram matching is investigated using a monotone gray level transformation, which always assigns all picture points of a given gray level i to another gray level T(i) such that if i ≥ j, then T( i)≥ T( j). The objective is to find a transformed version of a given picture such that an error measure between the gray level histogram of the transformed picture and that of a reference picture is minimized. In a previous paper (S. K. Chang and Y. W. Wong, Comm. ACM 21, No. 10, October 1978, 835–840) we presented an O( k 1 × k 2) depth-first tree search algorithm to find an optimal monotone transformation using L 1 norm (sum of absolute differences) as the error measure, where k 1 and k 2 are the number of gray levels of the given picture and the reference picture, respectively. The same problem using L n norm as the error measure is investigated in this paper. A breadth-first tree search algorithm with a cutoff thresholdis described, which has time complexity O( k 1 2 × k 2). Applications of histogram matching to similarity retrieval are discussed.