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.

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 ...

In this paper we study the problem of on-line allocation of routes to virtual circuits (both point-topoint and multicast) where the goal is to minimize the required bandwidth. We concentrate on the case of permanent virtual circuits (i.e., once a circuit is established, it exists forever), and describe an algorithm that achieves an O(log n) competitive ratio with respect to maximum congestion, where n is the number of nodes in the network. Informally, our results show that instead of knowing all of the future requests, it is sufficient to increase the bandwidth of the communication links by an O(log n) factor. We also show that this result is tight, i.e. for any on-line algorithm there exists a scenario in which O(log n) increase in bandwidth is necessary. We view virtual circuit routing as a generalization of an on-line load balancing problem, defined as follows: jobs arrive on line and each job must be assigned to one of the machines immediately upon arrival. Assigning a job to a machine increases this machine’s load by an amount that depends both on the job and on the machine. The goal is to minimize the maximum load. For the related machines case, we describe the first algorithm that achieves constant competitive ratio. For the unrelated case (with n machines), we describe a new method that yields O(log n)-competitive

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.

Emerging high speed networks will carry traffic for services such as video-on-demand and video teleconferencing -- that require resource reservation along the path on which the traffic is sent. High bandwidth-delay product of these networks prevents circuit rerouting, i.e. once a circuit is routed on a certain path, the bandwidth taken by this circuit remains unavailable for the duration (holding time) of this circuit. As a result, such networks will need effective routing and admission control strategies. Recently developed online routing and admission control strategies have logarithmic competitive ratios with respect to the admission ratio (the fraction of admitted circuits). Such guarantees on performance are rather weak in the most interesting case where the rejection ratio of the optimum algorithm is very small or even 0. Unfortunately, these guarantees can not be improved in the context of the considered models, making it impossible to use these models to identify algorithms th...

We describe sequential and parallel algorithms that approximately solve linear programs with no negative coefficients (a.k.a. mixed packing and covering problems). For explicitly given problems, our fastest sequential algorithm returns a solution satisfying all constraints within a ¦ ¯ factor in Ç Ñ � ÐÓ � Ñ � ¯ time, where Ñ is the number of constraints and � is the maximum number of constraints any variable appears in. Our parallel algorithm runs in time polylogarithmic in the input size times ¯   � and uses a total number of operations comparable to the sequential algorithm. The main contribution is that the algorithms solve mixed packing and covering problems (in contrast to pure packing or pure covering problems, which have only “� ” or only “� ” inequalities, but not both) and run in time independent of the so-called width of the problem. 1. Background Packing and covering problems are problems that can be formulated as linear programs using only non-negative coefficients and non-negative variables. Special cases include pure packing problems, which are of the form Ñ�Ü � ¡ Ü � �Ü � � � and pure covering problems, which are of the form Ñ�Ò � ¡ Ü � �Ü � ��. Lagrangian-relaxation algorithms are based on the following basic idea. Given an optimization problem specified as a collection of constraints, modify the problem by selecting some of the constraints and replacing them by a continuous “penalty ” function that, given a partial solution Ü, measures how close Ü is to violating the removed constraints. Construct a solution iteratively in small steps, making each choice to maintain the remaining constraints while minimizing the increase in the penalty function. While Lagrangian-relaxation algorithms have the disadvantage of producing only approximately optimal (or approximately feasible) solutions, the algorithms have the fol-

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 minimum-cost multicommodity flow problem involves simultaneously shipping multiple commodities through a single network so that the total flow obeys arc capacity constraints and has minimum cost.

We start with definitions given by Plotkin, Shmoys, and Tardos [16]. Given A ∈ IR m×n, b ∈ IR m and a polytope P ⊆ IR n,thefractional packing problem is to find an x ∈ P such that Ax ≤ b if such an x exists. An ɛ-approximate solution to this problem is an x ∈ P such that Ax ≤ (1 + ɛ)b. Anɛ-relaxed decision

We present the first combinatorial approximation scheme that yields a pure approximation guarantee for linear programs that are either covering problems with upper bounds on variables, or their duals. Existing approximation schemes for mixed covering and packing problems do not simultaneously satisfy packing and covering constraints exactly. We present the first combinatorial approximation scheme that returns solutions that simultaneously satisfy general positive covering constraints and upper bounds on variable values. For input parameter ffl? 0, the returned solution has positive linear objective function value at most 1 + ffl times the optimal value. The general algorithm requires O(ffl2m log(cTu)) iterations, where c is the objective cost vector, u is the vector of upper bound values, and m is the number of variables. Each iteration uses an oracle that finds an (approximately) most violated constraint. A natural set of problems that our work addresses are linear programs for various network design problems: generalized Steiner network, vertex connectivity, directed connectivity, capacitated network design, group Steiner forest. The integer versions of these problems are all NP-hard. For each of them, there is an approximation algorithm that rounds the solution to the corresponding linear program relaxation. If the LP solution is not feasible, then the corresponding integer solution will also not be feasible. Solving the linear program is often the computational bottleneck in these problems, and thus a fast approximation scheme for the LP relaxation means faster approximation algorithms. For these applications, we introduce a new modification of the push-relabel maximum flow algorithm that allows us to perform each iteration in amortized O(jEj+jV j log jV j) time, instead of one maximum flow per iteration that is implied by the straight forward adaptation of our general algorithm. In conjunction with an observation that reduces the number of iterations to jEj log jV j for f0; 1g constraint matrices, the modification allows us to obtain an algorithm that is faster than existing exact or approximate algorithms by a factor of at least O(jEj) and by a factor of O(jEj log jV j) if the number of demand pairs is \Omega (jV j).