This paper considers the problem of designing fast, approximate, combinatorial algorithms for multicommodity flows and other fractional packing problems. We provide a different approach to these problems which yields faster and much simpler algorithms. Our approach also allows us to substitute shortest path computations for min-cost flow computations in computing maximum concurrent flow and min-cost multicommodity flow; this yields much faster algorithms when the number of commodities is large.

This paper presents fast algorithms that find approximate solutions for a general class of problems, which we call fractional packing and covering problems. The only previously known algorithms for solving these problems are based on general linear programming techniques. The techniques developed in this paper greatly outperform the general methods in many applications, and are extensions of a method previously applied to find approximate solutions to multicommodity flow problems. Our algorithm is a Lagrangean relaxation technique; an important aspect of our results is that we obtain a theoretical analysis of the running time of a Lagrangean relaxation-based algorithm. We give several applications of our algorithms. The new approach yields several orders of magnitude of improvement over the best previously known running times for algorithms for the scheduling of unrelated parallel machines in both the preemptive and the non-preemptive models, for the job shop problem, for th...

All previously known algorithms for solving the multicommodity flow problem with capacities are based on linear programming. The best of these algorithms [15] uses a fast matrix multiplication algorithm and takes O(k 3:5 n 3 m :5 log(nDU )) time for the multicommodity flow problem with integer demands and at least O(k 2:5 n 2 m :5 log(nffl \Gamma1 DU )) time to find an approximate solution, where k is the number of commodities, n and m denote the number of nodes and edges in the network, D is the largest demand, and U is the largest edge capacity. Substantially more time is needed to find an exact solution. As a consequence, even multicommodity flow problems with just a few commodities are believed to be much harder than single-commodity maximum-flow or minimum-cost flow problems. In this paper, we describe the first polynomial-time combinatorial algorithms for approximately solving the multicommodity flow problem. The running time of our randomized algorithm i...

We describe fully polynomial time approximation schemes for various multicommodity flow problems in graphs with m edges and n vertices. We present the first approximation scheme for maximum multicommodity flow that is independent of the number of commodities k, and our algorithm improves upon the runtime of previous algorithms by this factor of k, performing in O (ffl \Gamma2 m 2 ) time. For maximum concurrent flow, and minimum cost concurrent flow, we present algorithms that are faster than the current known algorithms when the graph is sparse or the number of commodities k is large, i.e. k ? m=n. Our algorithms build on the framework proposed by Garg and Konemann [4]. They are simple, deterministic, and for the versions without costs, they are strongly polynomial. Our maximum multicommodity flow algorithm extends to an approximation scheme for the maximum weighted multicommodity flow, which is faster than those implied by previous algorithms by a factor of k= log W where W is ...

After several decades of sustained research and testing, linear programming has evolved into a remarkably reliable, accurate and useful tool for handling industrial optimization problems. Yet, large problems arising from several concrete applications routinely defeat the very best linear programming codes, running on the fastest computing hardware. Moreover, this is a trend that may well continue and intensify, as problem sizes escalate and the need for fast algorithms becomes more stringent. Traditionally, the focus in optimization algorithms, and in particular, in algorithms for linear programming, has been to solve problems "to optimality." In concrete implementations, this has always meant the solution ofproblems to some finite accuracy (for example, eight digits). An alternative approach would be to explicitly, and rigorously, trade o# accuracy for speed. One motivating factor is that in many practical applications, quickly obtaining a partially accurate solution is much preferable to obtaining a very accurate solution very slowly. A secondary (and independent) consideration is that the input data in many practical applications has limited accuracy to begin with. During the last ten years, a new body ofresearch has emerged, which seeks to develop provably good approximation algorithms for classes of linear programming problems. This work both has roots in fundamental areas of mathematical programming and is also framed in the context ofthe modern theory ofalgorithms. The result ofthis work has been a family ofalgorithms with solid theoretical foundations and with growing experimental success. In this manuscript we will study these algorithms, starting with some ofthe very earliest examples, and through the latest theoretical and computational developments.

Minimum cost multicommodity flow is an instance of a simpler problem (multicommodity flow) to which a cost constraint has been added. In this paper we present a general scheme for solving a large class of such "cost-added" problems---even if more than one cost is added. One of the main applications of this method is a new deterministic algorithm for approximately solving the minimumcost multicommodity flow problem. Our algorithm finds a (1 + ffl) approximation to the minimum cost flow in ~ O(ffl \Gamma3 kmn) time, where k is the number of commodities, m is the number of edges, and n is the number vertices in the input problem. This improves the previous best deterministic bounds of O(ffl \Gamma4 kmn 2 ) [9] and ~ O(ffl \Gamma2 k 2 m 2 ) [15] by factors of n=ffl and fflkm=n respectively. In fact, it even dominates the best randomized bound of ~ O(ffl \Gamma2 km 2 ) [15]. The algorithm presented in this paper efficiently solves several other interesting generali...

The following problem arises in the study of lightwave networks. Given a demand matrix containing amounts to be routed between corresponding nodes, we wish to design a network with certain topological features, and in this network, route all the demands, so that the maximum load (total flow) on any edge is minimized. As we show, even small instances of this combined design/routing problem are extremely intractable. We describe computational experience with a cutting plane algorithm for this problem.

We show that an \epsilon-approximate solution of the cost-constrained K-commodity flow problem on an N-node M-arc network G can be computed by sequentially solving O(K(\epsilon^{-2} log K) log M log(\epsilon^{-1}K) single-commodity minimum-cost flow problems on the same network. In particular, an approximate minimumcost multicommodity flow can be computed in O^~(\epsilon^{-2}KNM) running time, where the notation O^~(.) means "up to logarithmic factors". This result improves the time bound mentioned in Grigoriadis and Khachiyan (1994) by a factor of M/N and that developed recently in Karger and Plotkin(1995) by a factor of \epsilon^{-1}. We also provide a simple O^~(NM)-time algorithm for singlecommodity budget-constrained minimum-cost flows which is O^~(\epsilon^{-3}) times faster than the algorithm of Karger and Plotkin (1995).

The multicommodity flow problem involves simultaneously shipping multiple commodities through a single network so that the total amount of flow on each edge is no more than the capacity of the edge. This problem can be expressed as a large linear program, and most known algorithms for it, both theoretical and practical, are linear programming algorithms designed to take advantage of the structure of multicommodity flow problems. The size of the linear programs, however, makes it prohibitively difficult to solve large multicommodity flow problems. In this paper, we describe and examine a multicommodity flow implementation based on the recent combinatorial approximation algorithm of Leighton et al. [13]. The theory predicts that the running time of the algorithm increases linearly with the number of commodities. Our experiments verify this behavior. The theory also predicts that the running time increases as the square of the desired precision. Our experiments show that the running time ...

... Min-Cost Flow problem, where the mutual capacity constraints are dualized and the resulting Lagrangean Dual is solved with a dual-ascent algorithm belonging to the class of Bundle methods. Although decomposition approaches to block-structured Linear Programs have been reported not to be competitive with general-purpose software, our extensive computational comparison shows that, when carefully implemented, a decomposition algorithm can outperform several other approaches, especially on problems where the number of commodities is “large” with respect to the size of the graph. Our specialized Bundle algorithm is characterized by a new heuristic for the trust region parameter handling, and embeds a specialized Quadratic Program solver that allows the efficient implementation of strategies for reducing the number of active Lagrangean variables. We also exploit the structural properties of the single-commodity Min-Cost Flow subproblems to reduce the overall computational cost. The proposed approach can be easily extended to handle variants of the problem.