A new approach to the maximum-flow problem

Reviewer: Charles Martel

Network flow algorithms are powerful tools that can be used to solve a wide range of optimization problems in management and logistics, such as scheduling of production in manufacturing facilities, routing of packets in communication networks, and assignment of routes in transportation networks. It is therefore not surprising that these algorithms have been extensively studied. The four papers reviewed below have all contributed new ideas for improving the performance of network flow algorithms, and a large number of new results based on these ideas have appeared over the last five years. The study of network flow provides an elegant setting in which a variety of algorithmic and data structures techniques can be applied. Assume that we are dealing with a network that has n nodes connected by m edges; the nodes may or may not be arranged into layers. Prior to 1985, virtually all the best network flow algorithms were based on the approach Dinic suggested in 1970 [1]: finding a maximum flow in a layered network requires that at most n ? 1 maximal flows be determined (a maximal flow is also called a blocking flow because it blocks further forward augmentations). Karzonov [2] was the first to show that the method of preflows, which allows nodes to temporarily have more incoming flow than outgoing flow, could be used to find a blocking flow in a time no more than n 2 times some constant ( O( n 2) time). This method results in an algorithm that runs in O( n 3) time. Both the algorithm of Malhotra, Kumar, and Maheshwari [3] and the wave algorithm of Tarjan [4], however, are much simpler and also achieve this time bound, still the best bound known for dense graphs with large capacities (new results have led to better algorithms for sparse graphs, for graphs with small capacities, and for parallel implementations). More details of network flow algorithms can be found in the books by Papadimitriou and Steiglitz [5] and Tarjan [6], and two recent surveys provide comprehensive treatments of newer results on network flows [7,8]. Shiloach and Vishkin The main focus of the paper by Shiloach and Vishkin is to find a maximum flow algorithm that can be implemented efficiently on a PRAM (parallel random access machine). The authors first describe an O( n 3) sequential algorithm that is a modification of Karzonov's algorithm. Their algorithm is more flexible with respect to the order in which it can process arcs (edges that are directed), and they demonstrate its ability to run in O( n 2 log n) time on a concurrent-read exclusive-write PRAM with n processors. The algorithm still deals with up to n ? 1 layered graphs sequentially; it gets its speedup by finding a blocking flow in each layered network in O( n log n) parallel time. The key to the parallel implementation of this algorithm is the introduction of several tree data structures that store information about the flows in the arcs incident to a node. This organization allows many processors to work in parallel, with each processor modifying the flow in a different arc. The authors' complete description of how to handle the parallel details also covers exactly how the processors are assigned to tasks. The resulting algorithm is fairly efficient; using n processors, it speeds up the best sequential algorithm by a factor of n/log n. (Note that since the maximum flow problem is P-complete [9] it is unlikely that the extreme speedups of an NC parallel algorithm can be achieved.) Sleator and Tarjan In an effort to improve the performance of Dinic's algorithm, several researchers have developed new data structures that store and manipulate the flows in individual arcs in the network. The first such data structures were developed independently by Shiloach in 1978 [10] and by Galil and Naamad in 1980 [11], and both made it possible to find a blocking flow in a layered network in O( m log 2 n) time, resulting in an O( mn log 2 n) time maximum flow algorithm. Sleator and Tarjan introduce the dynamic tree, a refinement of the previous data structures, and show how to use it to find a blocking flow in O( mn log n) time. Dynamic trees basically allow the flows in all arcs on one augmenting path to be updated in a single operation. The details of implementing dynamic trees are quite messy, but Sleator and Tarjan describe them as abstract data structures and go over the operations for manipulating them. They prove their running times and make it possible for the reader to design and analyze algorithms that use dynamic trees without becoming involved with all the details of their low-level implementation. The authors provide some fairly detailed code that implements the basic operations, which is nice if one wants to do an actual implementation. The code itself contains no comments, however (the accompanying text describes the code); I think comments would have made it much more useful. Dynamic trees have been used to improve a number of recent flow algorithms, but the computational experience reported in this paper, as well as more recent results [7], suggest that dynamic trees do not lead to faster running times in practice. The authors demonstrate the use of dynamic trees to speed up a number of other graph algorithms. Gabow Gabow suggests a general framework for designing efficient algorithms using scaling. The scaling approach as applied to network flow is to (1) halve all the capabilities, (2) recursively find a maximum flow for the reduced problem to get a flow f, and (3) double the flow in each arc and then use Dinic's algorithm to increase f to a maximum flow. Step (3) always starts with a flow that is at most m units less than the optimum, so Dinic's algorithm runs in O( mn) time. The number of halving phases is log N (where N is the largest capacity), so the algorithm runs in O( mn log N) time. Under the similarity assumption that N is bounded by a polynomial function of n, this bound is O( mn log n), which equals the bound of Sleator and Tarjan but with a much simpler algorithm. Gabow shows that scaling is a reasonable approach even when the capacities are not integral, and he applies his scaling technique to a number of other weighted graph problems. Goldberg and Tarjan All the algorithms discussed above are based on Dinic's layered graph approach; Goldberg discovered the first efficient algorithm which is not [12,13]. His algorithm uses the preflow approach suggested by Karzonov in which unbalanced nodes, whose incoming flow exceeds their outgoing flow, try to balance themselves by sending out additional flow to their neighbors. In Karzonov's algorithm (as well as in the Shiloach-Vishkin algorithm) a layered graph is used to determine which vertices an unbalanced vertex can send flow to. Goldberg's innovation was to use distance labels, which estimate the distance from a node to the sink t. Thus a node with label d tries to send its flow toward t by sending its excess flow to a node with label d ? 1. This approach leads to a more uniform treatment of vertices, allows vertices to be processed in a more flexible order, and provides a global measure of the progress of the algorithm. A straightforward implementation leads to an O( n 3) running time. Goldberg and Tarjan describe the details of the algorithm and its analysis. They also show how to implement the algorithm using dynamic trees to obtain a running time of O( mn log ( n 2/ m)). The flexible and uniform treatment of vertices in this approach makes it easier to add dynamic trees to the algorithm. The size of the dynamic trees which are used is restricted to at most n 2/ m; since the dynamic tree operations take O(log k) time (where k is the size of the tree), a bound of O( mn) on the number of dynamic tree operations yields the time bound. The algorithm's flexibility also makes it easy to parallelize. It can be implemented to run in O( n 2 log n) time on an exclusive-read exclusive-write PRAM using low-level details very similar to the Shiloach-Vishkin implementation. The Goldberg-Tarjan (GT) algorithm has the advantage of using only O( m) space, while the Shiloach-Vishkin algorithm seems to require a space at least n 2 times some constant (&OHgr;( n 2) space). Goldberg has implemented the parallel version of his algorithm on the Connection Machine and has reported speedups of over 100 compared to a sequential implementation [13]. It is difficult, however, to judge how much these results depend on the particular flow problems used. The GT algorithm can also be adapted fairly easily to run on asynchronous distributed parallel systems. Perhaps the strongest case for the importance of Goldberg and Tarjan's paper is the algorithms that have been developed from it. Gallo, Grigoriadis, and Tarjan [14] have shown how to use the GT algorithm to solve a large number of parametric problems a factor of n faster than previous algorithms. Ahuja and Orlin [15] have shown how to combine the ideas of the GT algorithm with the scaling approach to develop a fairly simple maximum flow algorithm which runs in O( mn + n 2 log N) time. In a more recent paper Ahuja, Orlin, and Tarjan [16] have added dynamic trees to the Ahuja-Orlin algorithm, which results in somewhat better time bounds.