Harold N. Gabow

A linear-time algorithm for a special case of disjoint set union

This paper presents a linear-time algorithm for the special case of the disjoint set union problem in which the structure of the unions (defined by a “union tree”) is known in advance. The algorithm executes an intermixed sequence of m union and find operations on n elements in O(m+n) time and O(n) space. This is a slight but theoretically significant improvement over the fastest known algorithm for the general problem, which runs in O(mα(m+n, n)+n) time and O(n) space, where a is a functional inverse of Ackermanns function. Used as a subroutine, the algorithm gives similar improvements in the efficiency of algorithms for solving several other problems, including two-processor scheduling, matching on convex graphs, finding nearest common ancestors off-line, testing a flow graph for reducibility, and finding two disjoint directed spanning trees. The algorithm obtains its efficiency by combining the fast algorithm for the general problem with table look-up on small sets, and requires a random access machine for its implementation. The algorithm extends to the case in which single-node additions to the union tree are allowed. The extended algorithm is useful in finding maximum cardinality matchings in nonbipartite graphs.

Scaling and related techniques for geometry problems

Three techniques in computational geometry are explored: <italic>Scaling</italic> solves a problem by viewing it at increasing levels of numerical precision; <italic>activation</italic> is a restricted type of update operation, useful in sweep algorithms; the <italic>Cartesian tree</italic> is a data structure for problems involving maximums and minimums. These techniques solve the minimum spanning tree problem in R<supscrpt>k</supscrpt><subscrpt>1</subscrpt> and R<supscrpt>k</supscrpt><subscrpt>@@@@</subscrpt> in O(<italic>n</italic>(<italic>lg n</italic>)<supscrpt>r</supscrpt><italic>lg lg n</italic>) time and O(<italic>n</italic>) space, where for R<supscrpt>k</supscrpt><subscrpt>@@@@</subscrpt> and k ≥ 3, r &equil; k−2; for R<supscrpt>k</supscrpt><subscrpt>1</subscrpt>, r &equil; 1, 2, 4 for k &equil; 3, 4, 5 and r &equil; k for k > 5. Other problems solved include R<supscrpt>k</supscrpt><subscrpt>1</subscrpt>and R<supscrpt>k</supscrpt> all nearest neighbors, post office and maximum spanning tree; R<supscrpt>k</supscrpt> maxima, R<supscrpt>k</supscrpt> rectangle searching problems, and Z<supscrpt>k</supscrpt><subscrpt>p</subscrpt> all nearest neighbors (1 ≤ <italic>p</italic> ≤ @@@@).

Efficient algorithms for finding minimum spanning trees in undirected and directed graphs

Recently, Fredman and Tarjan invented a new, especially efficient form of heap (priority queue). Their data structure, theFibonacci heap (or F-heap) supports arbitrary deletion inO(logn) amortized time and other heap operations inO(1) amortized time. In this paper we use F-heaps to obtain fast algorithms for finding minimum spanning trees in undirected and directed graphs. For an undirected graph containingn vertices andm edges, our minimum spanning tree algorithm runs inO(m logβ (m, n)) time, improved fromO(mβ(m, n)) time, whereβ(m, n)=min {i|log(i)n ≦m/n}. Our minimum spanning tree algorithm for directed graphs runs inO(n logn + m) time, improved fromO(n log n +m log log log(m/n+2)n). Both algorithms can be extended to allow a degree constraint at one vertex.

Faster scaling algorithms for network problems

This paper presents algorithms for the assignment problem, the transportation problem, and the minimum-cost flow problem of operations research. The algorithms find a minimum-cost solution, yet run in time close to the best-known bounds for the corresponding problems without costs. For example, the assignment problem (equivalently, minimum-cost matching in a bipartite graph) can be solved in

An efficient reduction technique for degree-constrained subgraph and bidirected network flow problems

O(\sqrt {nm} \log (nN))

Relaxed heaps: an alternative to Fibonacci heaps with applications to parallel computation

time, where

A matroid approach to finding edge connectivity and packing arborescences

n,m

On Two Problems in the Generation of Program Test Paths

, and N denote the number of vertices, number of edges, and largest magnitude of a cost; costs are assumed to be integral. The algorithms work by scaling. As in the work of Goldberg and Tarjan, in each scaled problem an approximate optimum solution is found, rather than an exact optimum.

Algorithms for two bottleneck optimization problems

Efficient algorithms are given for the bidirected network flow problem and the degree-constrained subgraph problem. Four versions of each are solved, depending on whether edge capacities/multiplicities are one or arbitrary, and whether maximum value/maximum cardinality or minimum cost/maximum weight is the objective. A version of the shortest path problem is also efficiently solved. The algorithms use a reduction technique that solves one problem instance by reducing to a number of problems.

Two Algorithms for Generating Weighted Spanning Trees in Order

The relaxed heap is a priority queue data structure that achieves the same amortized time bounds as the Fibonacci heap—a sequence of m decrease_key and n delete_min operations takes time O(m + n log n). A variant of relaxed heaps achieves similar bounds in the worst case—O(1) time for decrease_key and O(log n) for delete_min. Relaxed heaps give a processor-efficient parallel implementation of Dijkstras shortest path algorithm, and hence other algorithms in network optimization. A relaxed heap is a type of binomial queue that allows heap order to be violated.