E cient algorithms for the maximum concurrent ow

Ecient algorithms for the maximum concurrent ow problem Pierre-Olivier BAUGUION

∗

Walid BEN-AMEUR

Eric GOURDIN

†

‡

September 25, 2014

Abstract In this paper, we propose a generic decomposition scheme for the maximum concurrent ow problem. This decomposition scheme encompasses many models, including, among many others, the classical path formulation and the less studied tree formulation, where the ows of commodities sharing a same source vertex are routed on a set of trees. The pricing problem for this generic model is based on shortest-path computations. We show that the tree-based linear programming formulation can be solved much more quickly than the path or the aggregated arc-ow formulation. Some other decomposition schemes can lead to even faster resolution times. Finally, an ecient strongly polynomial-time combinatorial algorithm is proposed for the single-source case. Keywords: Maximum concurrent ow, column generation, decompositions, combinato-

rial algorithms. ∗ Télécom † Télécom

Sud Paris, Orange Labs., [email protected] Sud

Paris,

CNRS

Samovar

UMR

5157,

9

rue

Charles

Fourier

91000

Evry,

France,

[email protected]

‡ Orange

Labs., 38/40 rue du général leclerc 92130 Issy-Les-Moulineaux, France, [email protected]

1

1 Introduction Multicommodity ow models have been introduced long ago, as natural extensions of single ow problems, and, since then, have been extensively used in many contexts essentially to capture the movements of dierent types of commodities in various real-world activities such as shipment of goods in transportation models, routing of data streams in telecommunications networks, and distribution of energy, water ows, electricity (see, e.g., [1]). In this paper, we will focus on the

maximum concurrent ow problem (MCF). We con-

sider a directed graph with capacities on its arcs and a set of multicommodity demands to be routed through the graph. The objective is to compute the maximum fraction

γ

γ

such that a

of every demand can be simultaneously routed without exceeding the available

capacities. Besides the applications previously mentioned, MCF is the dual of the LP relaxation of the

sparsest cut problem.

A sparsest cut is a cut minimizing the ratio of the capacity of the

cut to the total demand that is separated by the cut. Many approximation algorithms for this problem are based on the solution of MCF (see, e.g., [26]). Another reason to consider MCF is that it gives rise to extremely dicult problems (see, e.g., [4, 5]). Even if MCF problems can be solved exactly in polynomial time using linear programming, the computing time can be quite long. In fact, the MCF problem can even be solved in strongly polynomial time using the approach of [22], slightly improved in [15]. The approach is based on the strongly polynomial-time algorithm of [27] to solve linear programs where the size of the entries of the constraint matrix is polynomially bounded in the dimension of the problem.

While the algorithms of [22] and [15] are nice theoretical

contributions, they are not really of practical interest. This led many researchers to design approximation algorithms for MCF [5, 8, 9, 16, 17, 21]. Flows are traditionally modeled with arc-ow variables specifying the amount of each commodity on each arc. By considering classical ow conservation constraints and capacity constraints one can easily model MCF. However, such models become inecient when the size of the linear program becomes huge.

One way to reduce the size of the LP consists

2

of aggregating the demands either by source or by destination (see [1, 11]). This generally allows one to solve larger instances. Another alternative is given by decomposition methods (see, e.g., [20] for a general review of decomposition methods in mathematical programming).

A very popular approach to

model and solve MCF consists of using path-ow variables that are iteratively introduced into a master LP by way of pricing subproblems, that reduce to simple shortest-path problems. It is indeed interesting to work with a small well-chosen subset of variables hoping to reach an optimal solution without having to generate all the variables of the model (many of which are most of the time useless in this process). A much less known formulation is based on tree variables instead of path variables. This formulation is proposed in [14] for minimum cost multicommodity ow problems. The conclusion of [14] was that this tree-based formulation is less ecient than the path-ow formulation. The contribution of our paper is threefold. First, we show that with today's computers and linear programming solvers, the conclusion of [14] does not hold at least for the MCF problem. In other words, our numerical experiments show that the tree-based formulation is much more ecient than the path-ow formulation. Second, we present a more general decomposition technique (including the tree decomposition). The column-generation algorithm corresponding to this decomposition is still based on shortest-path computations. Extensive numerical experiments show that the computing time can be signicantly reduced using these decompositions. The third contribution of the paper is related to the special case where all commodities share the same source. We will describe an ecient strongly polynomial-time algorithm for this special case. This algorithm is also able to compute a sparsest cut in the single-source case. Notice that our strongly polynomial-time algorithm is valid only in the single-source case, while the algorithms of [22] and [15] are also valid for the multiple-source case. However, they are worse than our algorithm in terms of computational complexity. The rest of the paper is organized as follows. In addition to notation, some traditional

3

models are recalled in Section 2. A generic model is presented in Section 3 and proved to be correct. Section 4 is dedicated to the single-source case where a strongly polynomial-time algorithm is described. Numerical results are presented and commented upon in Section 5. Some conclusions follow in the nal section.

2 Notation and standard models We consider a capacitated directed graph is the set of arcs. Let Given an arc

|V | = n

a ∈ A,

let

v − (a)

amount of ow that each arc A commodity

k

K

where

V

is the set of vertices and

(resp.

v + (a))

a.

be the tail (resp. head) of

dk > 0

sk ∈ V ,

a destination (or sink) vertex

(also called demand) to carry from

sk

to

tk

i

and

Given a subset of vertices

When

U = {v}

δ + ({v})

and

tk ∈ V

in the graph

G.

the set of all commodities. Without loss of generality, we will assume that

dened between the vertices

and

The maximum

a ∈ A can carry is called its capacity and is denoted by ca ≥ 0.

there is at most one commodity for each pair of (source, destination).

v − (a) ∈ U

A

|A| = m.

is dened by a source vertex

and an amount of ow We denote by

and

G = (V, A)

v + (a) ∈ / U.

j,

we will sometimes denote by

U ⊂ V,

let

δ + (U )

dij

v,

the demand.

a ∈ A

denote the set of arcs

The set of incoming arcs is denoted by

for some vertex

For a commodity

then we use the notation

δ + (v)

such that

δ − (U ) = δ + (V \ U ). and

δ − (v)

instead of

δ − ({v}).

For each commodity The total ow on link

a,

k∈K

and

denoted by

a ∈ A, fak fa ,

denotes the ow on arc

is then given by

∑

fak .

due to demand

k.

The maximum concurrent

k∈K ow problem can be formulated using the following arc-ow model.

4

a

 max γarc ,      ∑ ∑  k   f − fak = 0,  a   − +  a∈δ (v) a∈δ (v)    ∑ ∑ k fa − fak = γarc dk , (M CF arc )   a∈δ − (sk )  a∈δ+ (sk )   ∑    fak ≤ ca ,     k∈K    k fa ≥ 0,

(1)

∀k ∈ K, v ∈ V \ {sk , tk },

(2)

∀k ∈ K ,

(3)

∀a ∈ A,

(4)

∀a ∈ A, k ∈ K .

(5)

A well-known technique to reduce the size of the previous LP consists of aggregating the commodities either by source or by destination. Let Let

T (i)

S

be the set of all sources:

S = {sk }k∈K .

be the set of vertices that are destinations for commodities having their source in

i: T (i) = {tk }k∈K:sk =i . a commodity

h ∈ K agg

and the demand value

Let

K agg

be the set of commodities aggregated by source. Then

sh ∈ S ,

is now dened by a source h

ds

j

for each

j ∈ T (sh ).

the set of destinations

T (sh )

The source-aggregated formulation is given

below.

 max γagg ,      ∑ ∑  h   − g gah = 0,  a   − +  a∈δ (v) a∈δ (v)    ∑ ∑ h h ga − gah = γagg ds v , (M CF agg )   a∈δ + (v)  a∈δ− (v)   ∑    gah ≤ ca ,    agg  h∈K    h ga ≥ 0, Notice that

gah

denotes here the ow on arc

a

(6)

∀h ∈ K agg , v ̸= sh , v ∈ / T (sh )

(7)

∀h ∈ K agg , v ∈ T (sh ),

(8)

∀a ∈ A,

(9)

∀a ∈ A, h ∈ K agg .

(10)

related to the aggregated commodity

h ∈ K agg . The equivalence of

M CF arc

and

It is also well known that an between

s and t.

s-t

M CF agg

is a standard result [1].

ow can be equivalently described by ows on paths

More precisely, a ow between

s and t is equivalent to a set of nonnegative

ows on paths, plus ows on circuits. However, in the case of the maximum concurrent ow problem, the cancellation of the ow on a circuit does not deteriorate the objective function.

5

In other words, there are optimal solutions without ows on circuits. We can then write

∑

fak =

φkp , a ∈ A, k ∈ K,

(11)

p∈P k :p∋a where

Pk

denotes the set of all simple paths (without circuits) between

a nonnegative number representing the ow on path

k

can hence be routed over a set of paths in

P ij

the set of paths between vertices

i

and

P k.

p

for commodity

(instead of

γarc

k,

the proportion of

and

γagg )

γ

and

tk ,

φkp

k.

Each commodity

and

is

As before, in some cases we will denote by

j.

We recall the standard path-ow model based on path variables each commodity

sk

devoted to each path

p ∈ Pk

λkp

representing, for

γpath

and denoting by

the objective function

 max γpath ,     ∑ ∑    λkp dk ≤ ca ,    k k∈K p∈P :p∋a (M CF path ) ∑   λkp ≥ γpath ,     p∈P k     λkp ≥ 0,

(12)

∀a ∈ A,

(13)

∀k ∈ K ,

(14)

∀k ∈ K, p ∈ P k .

(15)

λkp dk = φkp .

Note that, following our previous notation, we have

As a result, the left-hand

side of the capacity constraints (13) represents the total amount of ow on arc the left-hand side represents the proportion of trac shipped between proportion should not be less than the factor

γpath

sk

a.

and

In (14),

tk .

This

which is maximized in the objective

function (12). Consequently, for any optimal solution, we will have

∗ = min γpath k∈K

∑

λkp .

(16)

p∈P k

A much less known formulation is based on directed tree formulations. Given a source vertex

i ∈ S,

let

spanning at least a rooted tree

Ti

denote the set of directed trees (or arborescences) rooted at

T (i).

τ ∈ Ti

i

and

Note that all the trees we consider from now on are directed. Given

and an arc

that the unique path in

τ,

a ∈ A,

connecting

i

we denote by to

j,

Vaτ

the set of vertices

contains the arc

Vaτ = {j ∈ T (i), ∃p ∈ P ij

6

such that

j ∈ T (i)

such

a:

p ⊂ τ, p ∋ a}.

(17)

In other words, of

τ

tree

rooted at

τ ∈ Ti

Vaτ

is the intersection of

v + (a).

In the model we propose, a common variable

and, for each commodity

ow are sent to

tk

T (i) with the set of vertices spanned by the subtree

k∈K

τ.

is assigned to each

i (sk = i), βτi dk

having its source in

along the unique path in the tree

βτi

units of

Let us consider the following linear

program:

(M CF tree )

 max γtree ,     ∑ ∑ ∑    β i dij ≤ ca ,    i∈S τ ∈T i : j∈V τ τ τ ∋a

(18)

∀a ∈ A,

(19)

∀i ∈ S ,

(20)

∀i ∈ S, τ ∈ T i .

(21)

a

∑    βτi ≥ γtree ,     i  τ ∈T   i βτ ≥ 0,

In constraints (19), the left-hand side sums over all trees containing the arc

a,

all the trac

from the root vertex (the common source of some commodities) towards the destinations of these commodities, which hence represents the total trac on arc require that the sum of

βτi

over the trees having a common source

a. i

In constraints (20), we

should be at least

γtree .

The equivalence of the tree-based formulation and the path-based formulation was already proved in [14]. The proof of [14] is based on a Dantzig-Wolfe decomposition of formulation

M CFagg

known to be equivalent to

M CFarc .

Trees were also used in the approximation

algorithm of [16]. Table 1 summarizes the main notation related to arc-ow, path-ow and tree-based formulations.

3 A generic formulation and resolution approaches As for any multicommodity ow problem, an optimal solution of MCF is comprised of sets of paths carrying some ows from the sources to the destinations. Following standard decomposition mechanisms (namely the Dantzig-Wolfe decomposition method applied to an arc-ow formulation), one can easily derive the path-ow model.

Other models could be

obtained by handling dierently the variables in an initial formulation, such as, for instance, the arc-ow model. In an alternative approach, one can also start from the path-ow model

7

and "aggregate" the path variables into subsets, each subset being then modeled by a single new variable. More precisely, any partition of the demand set Consider the partition

K

can induce a new model.

Γ(K) = {X1 , X2 , . . . , Xq }: q ∪

Xj = K, Xj ∩ Xℓ = ∅, ∀j, ℓ = 1, ..., q, j ̸= ℓ.

(22)

j=1 For each subset of

Υj

Xj ∈ Γ(K),

we dene an associated set

Υj =

is hence a set of paths, one path for each commodity in

associate a dierent variable derived for MCF:

(M CF gener )

αjϱ

to each

ϱ ∈ Υj .

means that

p p

corresponding to a commodity

k ∈ Xj

is the path related to commodity

paths, one for each commodity

k ∈ Xj

if

Xj .

P k.

Each element

In our new model, we

(23)

∀a ∈ A,

(24)

∀j = 1, . . . , q ,

(25)

∀j = 1, . . . , q, ϱ ∈ Υj .

(26)

p∋a

Observe that in constraint (24) related to an arc if the path

k∈Xj

A generic aggregated model can then be

 max γgener ,    q ∑   ∑ ∑ ∑    dk ≤ ca , αjϱ    j=1 ϱ∈Υj k k∈Xj p∈ϱ|P ∑ ϱ    αj ≥ γgener ,     ϱ∈Υj     αϱ ≥ 0, j

∏

k

in

a,

we add all ow contributions

contains the arc

ϱ

a.

(remember that

ϱ

Notation

αjϱ dk

p ∈ ϱ|P k

represents a set of

ϱ ∈ Υj ).

This generic formulation encompasses a wide range of models, including the path model (taking

Γ(K) = K ) and the tree model by considering the partition Γ(K) where each subset

contains all commodities having the same source (more details are given in the discussion following (38) and Lemma 3.3). The dual problem can be written as follows:

∗ γgener =

 ∑  min ca µa ,     a∈A    q  ∑    ψ j ≥ 1,

(27)

(28)

  ∑    dk lenkϱ (µ) ≥ ψ j     k∈Xj    µa , ψ j ≥ 0, j=1

8

∀j = 1, . . . , q, ϱ ∈ Υj ,

(29)

∀a ∈ A, j = 1, . . . , q ,

(30)

where

µa

lenkϱ (µ)

denotes the length of the path related to commodity

on the arcs. Note that

(µa )a∈A

and

(ψ j )j=1,...,q

k,

in

ϱ,

with weights

are the sets of dual variables associated

respectively with the constraints (24) and (25). We show below that the generic model is correct.

Theorem 3.1.

Given any partition Γ(K) = {X1 , X2 , . . . , Xq }, the corresponding generic

∗ ∗ formulation M CF gener is exact: γgener = γpath .

Proof:

solution of

M CF gener

An optimal solution of

M CF path

can obviously be used to build a feasible

having the same objective value. This clearly implies that

∗ γgener ≤

∗ γpath . To prove that the reverse inequality holds, we rst use (29) to deduce that

∑

ψ j ≤ min

ϱ∈Υj

dk lenkϱ (µ), ∀j = 1, . . . , q.

k∈Xj

Since the sum of minimum lengths is achieved along shortest paths, we have

ψj ≤

∑

min dk lenkp (µ), ∀j = 1, . . . , q,

k∈Xj Letting

ν k = minp∈P k dk lenkp (µ),

(31)

p∈P k

we have

k ν k ≤ dst lenst p (µ) = d

∑

µa , ∀k ∈ K, p ∈ P k .

(32)

ψ j ≥ 1.

(33)

a∈p Moreover, by (31) and (28), we have

∑

νk ≥

k∈K Hence, the solution of the dual of

∗ γpath =

It follows that

M CFgener

q ∑ j=1

is also feasible for the dual of

 ∑  min ca µa ,     a∈A   ∑    ν k ≥ 1, 

M CFpath :

(34)

(35)

k∈K

 ∑    µa ≥ ν k dk     a∈p    µa , ν k ≥ 0,

∗ ∗ γpath ≤ γgener . 

9

∀k ∈ K, p ∈ P k ,

(36)

∀a ∈ A, k ∈ K .

(37)

Remark 3.2.

While we assumed that the graph is directed, Theorem 3.1 is still valid if the

graph is undirected. We only have to consider undirected paths instead of directed paths. The proof of Theorem 3.1 does not change. To design an ecient model, one has to take into account two contradictory goals: (i) the more one aggregates information, the fewer variables are needed to express an optimal solution, and one can then hope to keep the master problem small during the column generation process; (ii) however, when the variables are more aggregated, it can become more dicult to nd the relevant variables needed to describe an optimal solution, and the number of iterations of the algorithm (i.e., the number of resolutions of the master problem) can increase. For the MCF, we have tested several models: the path model model

M CF tree ,

together with a model

into a single set, and a model

M CF rtr

M CF all

where

r

M CF path

and the tree

where all commodities are aggregated

trees are aggregated. Figure 1 illustrates

various aggregation/decomposition schemes: in the demand graph (a), each arc represents a commodity (the path model is based on this original set

K );

in (b), the commodities are

aggregated by sources; in (c), all commodities are aggregated into a single set; in (d), the trees obtained in (b) are aggregated two by two.

s1

t1

s1

t1

s1

t1

s1

t1

s2

t2

s2

t2

s2

t2

s2

t2

s3

t3

s3

t3

s3

t3

s3

t3

t4

s4

t4

s4

t4

s4

s4 (a)

(b)

(c)

t4 (d)

Figure 1: Various aggregation/decomposition schemes.

In Section 5, we will consider the cases

r = 2 (M CF 2tr )

and

r = 4 (M CF 4tr ).

The MCF problem expressed according to the various models we propose here can be solved rather eciently by a column-generation algorithm. number of variables (= paths, trees, subsets of paths,...)

10

The basic idea is that, the

being huge, it is reasonable to

work only with a limited subset of variables, dening a so-called Master problem.

Then

variables are added iteratively until no possible improvement can be obtained in the objective function.

Adding columns is equivalent to adding constraints to the dual problem.

M CFpath ,

looking at inequalities (36), we can see that, in the model can be generated by computing a shortest path between

(µa )a∈A .

If the weight of the shortest path is less than

sk

and

tk

By

the path variables

with respect to weights

k

ν , then a constraint is added to the dk

dual problem (equivalently, a column is added to the primal problem). More generally, considering the generic model and using (29), the reduced cost of the variable

αjϱ

is given by

rϱj = ψ j −

∑

∑

dk lenkp (µ),

(38)

k∈Xj p∈ϱ|P k It follows that, in all our path-based models, the pricing problem amounts to solving one or several shortest-path problems (one for each commodity involved in a subset

Xj ).

When

only some new variables are considered, it is hence also interesting to design aggregated variables where all shortest-path problems can be solved at once.

This is the case with

the tree model, where the pricing of a single tree variable requires computation of the shortest-path tree rooted at

s

with respect to weights

(µa )a∈A

(instead of all shortest-paths

individually). In fact, it suces to compute the shortest-path tree spanning

T (s).

Also note

that, since only shortest paths are relevant as potential variables (or pieces of variables) in the master problems, it follows that the generic model where all paths are aggregated by sources is indeed equivalent (or can be reduced) to the tree model (because only shortestpath trees will be generated in the resolution process). This is stated in a more formal way in the following lemma.

Lemma 3.3.

∗ ∗ γgener = γtree .

Proof: One can directly use the equivalence of

M CF tree

and

M CF path

proved in [14]

in addition to Theorem 3.1 to prove the lemma. However, we provide a dierent proof not using the result of [14]. Let us consider the generic formulation where the set of commodities according to the source of each commodity. Consider the formulation

11

K

is partitioned

M CF gener

obtained

for this case.

contain more variables than in

M CF gener

By comparing

M CF tree .

M CF tree

∗ γtree =

s ∈ S,

one can see that

M CF gener

might

∗ ∗ γgener ≥ γtree .

M CF tree :  ∑  ca µa ,  min    a∈A   ∑    ϕs ≥ 1, 

(39)

(40)

s∈S

 ∑  s   dst lenst  τ (µ) ≥ ϕ    t∈T (s)    µa , ϕs ≥ 0,

Consider a solution of the dual of each

M CF tree ,

since only paths forming a rooted trees are considered

This clearly implies that

Let us write the dual of

to

∑

we should have

M CF tree

∀s ∈ S, τ ∈ T s ,

(41)

∀a ∈ A, s ∈ S .

(42)

dened by

s dst lenst τ (µ) ≥ ϕ

where

(νa )a∈A τ

and

(ϕs )s∈S .

Then, for

is a tree of shortest paths (in

t∈T (s) sense of

µ)

) from

s.

Let

ϱ

be any variable of the generic formulation associated with the set of commodities

having

s

as a source. Here

s

as a source.

st lenst ϱ ≥ lenτ .

ϱ

represents a set of paths: one path for each commodity having

Then, using the fact that

τ

This immediately implies that

is the shortest-path tree rooted at

∑

s dst lenst ϱ (µ) ≥ ϕ .

s,

Consequently,

we have

(νa )a∈A

t∈T (s) and

(ϕs )s∈S

leads to

dene a feasible solution of the dual of

M CF gener

given by (27)(30). This

∗ ∗ γtree ≥ γgener .

Combination of the two inequalities proves the wanted result. One issue that is specic to

M CF rtr



is to decide how to aggregate the various trees (or,

in other words, which sources of commodities should be combined). We propose a heuristic approach to decide how two (or more) subsets of commodities (both sharing a common source) should be aggregated. The main idea is to merge dierent sources that are linked by a high capacity round-trip path (see Algorithm 1). These sources are generally close to each other in the graph and can be expected to be routed similarly. In other words, given two such sources expect the optimal routings of the commodities having either many arcs. Thus, the variable

αjϱ

s

or

s′

s

and

s′ ,

we

as a source to share

corresponding to these aggregated commodities will not

appear in too many constraints (24).

12

Algorithm 1 aggregation heuristic for model

M CF rtr

Require: r the maximum cardinality to reach for each aggregate, Ensure: a partition

H

of the set of sources

1:

H ← {hs = {s} : s ∈ S} H

2:

C(hs ) ← ∞

3:

F use ← true

4:

while

contains

|S|

S

subsets; each subset contains one source

assign an innite capacity to

F use = true

5:

BestC ← −1

6:

for all

G(V, A) capacitated graph

C(hs )

for each aggregate (subset)

hs

do

best capacity found

h, h′ ∈ H , h ̸= h′ do { } c ← min C(h), C(h′ ), min ′ CapacityM ax(i, j), min CapacityM ax(i, j) ′

7:

i∈h,j∈h

c > BestC

if

8:

and

i∈h ,j∈h

|h′ | + |h| ≤

r

BestC ← c ; h1 ← h′ ; h2 ← h

9:

then

store capacity and subsets to be aggregated

end if

10:

11:

end for

12:

if

BestC > −1

then

h1 ← h1 ∪ h2

13:

capacity of

;

H ← H \ h2

;

C(h1 ) ← BestC

fuse the two aggregates and update

h1

else

14:

F use ← f alse

15:

16:

end if

17:

end while

The algorithm aims at computing a partition responds to a subset of

S

containing at most

cording to their sources. In other words, if where

Xi

H = Γ(S) such that each element of H

r sources.

cor-

Commodities are then partitioned ac-

H = Γ(S) = {S1 , ..., Sl } then Γ(K) = {X1 , ..., Xl }

contains all commodities having their source in

Si .

Notice that there are some

partitions that cannot be obtained using our aggregation heuristic. For each pair of sources

i

and

j,

let

among all possible paths connecting

i

CapacityM ax(i, j) to

j.

denote the largest path capacity

The capacity of a path is the minimum of

capacities of the path arcs. Computing a largest capacity path is a classical problem that

13

can be solved by a modication of Dijkstra's algorithm (see, e.g., [1]). Given a subset of sources

C(h),

as the minimum of

C(h) =

min

i∈h,j∈h,j̸=i

h ⊂ S,

we dene the internal capacity of

CapacityM ax(i, j)

contains

|S|

denoted by

over all possible pairs of sources of

h.

Thus

CapacityM ax(i, j).

The algorithm rst creates an aggregate

H

h,

hs = {s} for each source s.

The initial partition

subsets. The internal capacity of each aggregate is initially innite (step 2).

A boolean variable

F use

is used to indicate whether it is possible to merge some subsets

without violating the cardinality constraint. It is initially equal to true (step 3). Then the subsets to be aggregated are repeatedly computed in the while loop. For all elements

h′

of

while

H, h1

we compute and

h2

C(h ∪ h′ )

(step 7).

BestC

h

and

is used to store the best internal capacity

represent the two subsets that might be aggregated.

BestC

is set to

−1

before starting the search for subsets to be merged (step 5). The best (in terms of capacity) possible aggregation satisfying the cardinality constraint (checked in step 8) is then used to update

H

(step 13). The capacity of the new subset

h1

is also updated (step 13).

Algorithm 1 should be considered as a possible aggregation heuristic to build a

M CF rtr

formulation. Better heuristics might exist. However, we only aim to show that it is possible to get formulations that are easier to solve than

M CF path

and

M CF tree .

4 The single-source maximum concurrent ow problem We already know that the MCF problem can be solved in strongly polynomial time using the algorithms of [22] and [15]. However, as previously mentioned, these algorithms are not of practical interest. We propose here an ecient strongly polynomial-time algorithm for the single-source case. We assume that all commodities

k∈K

share the same source vertex

s = sk .

We prove

that a variation of Edmonds-Karp's algorithm (originally designed for the Max-Flow problem [7]) can be used to solve our problem, namely, the single-source Maximum Concurrent Flow problem. The two main dierences are: (i) the fact that a minimum shortest-path tree spanning all

14

terminal vertices is built at each iteration (instead of a shortest path), and (ii) a maximum concurrent ow that can be sent on this tree is computed (instead of a maximum ow on a path). A formal description of the algorithm is now given. We still use that

ca > 0

T (s)

to denote the set of destinations. We assume without loss of generality

for each arc

a∈A

and that all vertices can be reached from

s

(if not, then the

vertex should be deleted). Algorithm 2 : single-source MCF Require: a directed graph

G = (V, A)

with capacities

(ca )a∈A

and a set of commodities

(s, tk , dk )k∈K . Ensure: the value

γ∗

of the maximum concurrent ow between

initialize

2:

while there exists a shortest-path tree

nd the maximum and

γ

such that ows

τ

spanning

γdk

T (s).

T (s)

in the residual graph do

can be concurrently routed in

augment the ow and update the residual graph

5:

γ∗ ← γ∗ + γ

between

s

end while

The value of

γ

is iteratively augmented by computing shortest-path trees with respect to

unit weights. These trees are computed in the the current ow equal to

fa ,

fa

on an arc

a

residual graph dened in the classical way:

a

if

is non-zero, then a reverse arc is considered with a capacity

while the capacity of

a

is reduced to

ca − fa

in the residual graph. Only arcs

with strictly positive capacities are considered in the residual graph (thus, if arc

τ

tk

4:

6:

and

γ ∗ ← 0.

1:

3:

s

fa = ca ,

the

does not belong to the residual graph).

Finding the maximum demands

dk

γ

in step 3 can be achieved easily: we only have to tag the initial

s and tk ∑

along the single path between

requirement on each arc

a given by

∑ k∈K

p∈P k ∩τ : p∋a

and hence obtain a cumulative demand

dk .

The maximum

γ

is then simply the

minimum over all arcs of the ratio of residual capacity to cumulative demand. In the fourth step, the ow on each arc and the residual graph are updated in the classical way (similar to the Ford-Fulkerson algorithm).

15

Before proving the correctness of the algorithm, let us recall some useful concepts. A (forward) cut in the graph by the set of arcs

δ + (U )

We use the notation when ow variables

δ + (U ): f (U, U ) =

fa

G

leaving this subset. Let

c(U, U ) =

∑

a∈δ + (U )

U =V \U

a∈δ + (U ) ca and

are considered,

∑

The sparsity of a cut

can be equivalently dened by a subset of vertices

f (U, U )

be the complement of

d(U, U ) =

∑ k∈K sk ∈S,tk ∈U

δ + (U )

U.

Similarly,

denotes the sum of ows on the arcs of

is dened as the ratio of capacities to demands:

c(U, U ) . d(U, U )

(43)

There is a well-known weak duality result: any concurrent ow value

χ(U, U )

dk .

or

fa .

χ(U, U ) =

to any cut sparsity

U ⊂V

γ

is less than or equal

and this hence also holds for the maximum concurrent ow and

the minimum cut sparsity:

γ ∗ ≤ χ∗ = min {χ(U, U ) : d(U, U ) ̸= 0}.

(44)

U ⊂V

It is also known that, in the general case, there is no strong duality between these two problems. Moreover, computing the sparsest cut is generally NP-hard. An

√ O( n)

approxi-

mation algorithm is proposed in [12].

Note that when

G

is undirected, the sparsest cut problem is also NP-hard (the instance

by Okamura-Seymour [23] is often cited to illustrate the duality gap) and considerable eorts have already been spent to design ecient approximation algorithms [11, 18, 24, 28], with much tighter approximation bounds (for instance (the graph made of all edges

{sk , tk })

√ O( log n)

in [2]). If the demand graph

does not contain as a subgraph, either three disjoint

edges or a triangle and a disjoint edge, then the duality gap is equal to 0 (see [17, 25]). This generalizes the two-commodity result of Hu [13].

Other special cases where there are no

duality gaps are reviewed in [25].

The situation is dierent in the single-source case. Using the maximum-ow minimumcut theorem, it is easy to see that strong duality holds in the single-source case. This holds also for the single-sink case [25].

16

Notice that in the single-source case, it is easy to check whether it is possible to carry all demands capacity

t.

γdk

γdk

through the network.

k ∈ K.

for each

One can add a new vertex

t

and an arc

(tk , t)

of

s

to

It is then sucient to compute a maximum ow from

γ

If the value of this ow is strictly less than

∑

dk ,

k∈K

we deduce that

γ∗ < γ.

This

graph transformation suggests that the single-source maximum concurrent ow problem can be solved by a sequence of maximum ows for various values of

λ

obtained within a binary

search. However, such approaches do not lead to strongly-polynomial algorithms. The main result of this section is given below.

Theorem 4.1.

The single-source maximum concurrent ow problem can be solved by Algo-

rithm 2 in O(m2 n) time. The proof of Theorem 4.1 is quite close to the correctness proofs of the Edmonds-Karp algorithm.

If Algorithm 2 stops, then the obtained γ ∗ is equal to the optimum of the

Lemma 4.2.

Maximum Concurrent Flow. Proof: The algorithm stops when there are no more rooted trees spanning

residual graph. This means that there exists a subset of vertices some destinations (U there exists a set

U

∩ T ̸= ∅)

such that

the demand:

that cannot be reached from the source

fa = ca

a result, for all destinations in

and

for all

T (s) ∩ U ,

f (U, U ) = γ ∗ d(U, U ).

γ ∗ d(U, U ) = c(U, U )

γ ∗ = χ∗

and

V.

a ∈ δ + (U )

Moreover, we have

χ∗

and since

and

f (U , U ) = 0.

fa = 0

More precisely,

for all

a ∈ δ − (U ).

f (U, U ) = c(U, U ).

is an upper bound,

γ∗

γ∗

As

times

It follows that

is hence optimal.



T (s), then there is also a rooted tree spanning

If not, then one could nd a set

f (U, U ) = c(U, U )

and

s.

in the

containing

all the incoming ow is used to satisfy

Observe that if there is a rooted tree spanning all vertices

U ⊂ V \ {s},

T (s)

U

containing

s

and

T (s)

This is of course impossible since

such that

U

U ̸= ∅

does not con-

tain destinations. In other words, at each iteration of the algorithm (except the last one), for any vertex

v.

Let li (s, v) be the length of the shortest path

(with respect to unit weights) at iteration

i,

where the number of iterations is incremented

there is a path from

s

to

v

after each ow augmentation. Let

Gi

be the residual graph at iteration

17

i

(before the ow

augmentation).

Lemma 4.3.

li (s, v) does not decrease during the algorithm for any vertex v ∈ V .

Proof: Assume that the result does not hold. Among all vertices for which

li+1 (s, v) < li (s, v), let

v

(45)

be a vertex such that li+1 (s, v) is minimal.

Let

u

be the predecessor of

v

in a shortest path from

s

to

v

in

Gi+1 .

We obviously have

li+1 (s, u) = li+1 (s, v) − 1. Since

li+1 (s, u) < li+1 (s, v), i

between iterations

and

i+1

(46)

the shortest-path length from

(by the choice of

v ).

s

to

u

does not decrease

In other words, we have

li (s, u) ≤ li+1 (s, u). Let us now show that the arc that

(u, v)

belongs to

Gi .

(u, v)

does not belong to

Then we can write li (s, v)

inequality leads to

li (s, v) ≤ 1 + li+1 (s, u).

contradicting (45).

Consequently, the arc

(47)

Gi .

Assume for a contradiction

≤ li (s, u) + 1.

Using (47), the previous

Now using (46), we get

(u, v)

is not present in

Gi

li (s, v) ≤ li+1 (s, v) but appeared only

after the ow augmentation. This is possible only if the opposite sense arc iteration i. In other words,

li (s, v) = li (s, u) − 1.

(v, u)

belongs to the shortest-path tree in

Using (47), the previous inequality leads to

By considering (46), we obtain li (s, v) A critical arc tree

τ

∑

is used at

This implies that

li (s, v) ≤ li+1 (s, u) − 1.

contradicting (45).



is an arc whose capacity is a limiting factor for the current rooted

(i.e., an arc minimizing the ratio of the residual capacity to the cumulative demand

∑ k∈K

a

≤ li+1 (s, v) − 2

Gi .

(v, u)

p∈P k ∩τ p∋a

dk ).

The tree used at each iteration contains at least one critical arc. Ob-

viously, if an arc is critical at iteration

Lemma 4.4.

i,

it will not be present in iteration

An arc cannot be critical more than 18

n 2

times.

i + 1.

Proof: Suppose that

(u, v)

is a reverse arc of an arc of

A.

is critical at iteration Since

(u, v)

i.

Notice that

(u, v)

A

is either in

belongs to the shortest-path tree, we can write

li (s, v) = li (s, u) + 1. Suppose that

(u, v)

is also critical at iteration

should be used at least once between iterations (i

< k < j)

or

(48)

j > i.

Then, the opposite sense arc

i

j.

and

(v, u)

In other words, there exists

k

such that

lk (s, u) = lk (s, v) + 1. Moreover, we know by the previous lemma that lk (s, v)

(49)

≥ li (s, v).

Combining this inequality

with equalities (48) and (49) directly leads to

lk (s, u) ≥ li (s, u) + 2.

(50)

In other words, after being critical at one iteration, each time that distance between

s and u increases at least by two units.

(except at the last iteration),

(u, v)

(u, v)

is critical, the

Since this distance is at most

cannot be critical more than

n 2 times.

n−1



The proof of Theorem 4.1 then follows easily. Since each arc cannot be critical in more than

n 2 iterations and the numbers of arcs is less than

Algorithm 2 stops after done in

O(m)

O(mn) iterations.

2m

(reverse arcs are also counted),

Moreover, computing a shortest-path tree can be

time by a breadth-rst-search algorithm.

Similar to the maximum ow problem, more sophisticated algorithms for the singlesource maximum concurrent ow problem might exist. This is left for further studies.

Observe that Algorithm 2 is also able to compute a sparsest cut in the single-source case. For example, if such that

s∈U

Corollary 4.5.

T (s) = V \ {s} minimizing

and

dk = 1

for

k ∈ K,

then we can compute a cut

δ + (U )

c(U,U ) . This is stated below for sake of completeness. |U |

Algorithm 2 computes a sparsest cut in O(m2 n) time (in the single-source

case). 19

Remark 4.6.

While we assumed that the graph is directed, Algorithm 2 can also be applied

when the graph is undirected. Similar to the classical maximum ow problem, one can replace each undirected edge {u, v} of capacity c by two arcs (u, v) and (v, u) each of capacity c. Since in the single-source case we can always cancel some ow to ensure that at least one of the two arcs (u, v) and (v, u) does not contain ow, replacing an undirected edge by two oppositely directed arcs does not change the value of the maximum concurrent ow.

5 Numerical Results Several numerical experiments have been conducted to compare the path-based formulation

M CF path ,

M CF agg

the tree-based formulation

M CF tree ,

the aggregated arc-ow formulation

and some special cases of the generic formulation

M CF gener .

Two types of data have been considered. We rst used the RMFGEN tool [6] to generate some instances of the MCF problem. The RMFGEN tool was initially used to create graphs for which the maximum ow problem is dicult to solve (see [6, 10]).

Then, it was also

observed (at least by [4]) that the MCF problem is dicult to solve for the instances built through the RMFGEN tool. The graphs generated by RMFGEN are dened by two parameters range

a and b, and a capacity

[Cmin , Cmax ]. The graph is made of b frames (grids) of size a × a.

In a frame, a vertex

is connected to its direct neighbors. The vertices of a frame are one-to-one connected with randomly chosen vertices from the next frame. Finally this graph has exactly and

6ba2 − 4ab − 2a2

ba2

vertices

arcs. More details about the instances generated by RMFGEN are

given in [6]. The second type of data corresponds to graphs generated with a random arc generator. The extremities of each arc are uniformly generated among the graph vertices (loops and parallel arcs are deleted). The arc generation process is repeated until we reach the desired number of arcs. The capacities are also chosen in the interval

[Cmin , Cmax ].

For all instances, demand values are uniformly picked from the interval

Cmin = 5

and

Cmax = 20.

20

[1, 10]

while

All numerical experiments were conducted on a computer with an Intel Core 2 Duo P8700 processor running at 2.53GHz, and with a RAM size of 3.48 GB. We used the solver Xpress (Mosel 3.20 - mmsystem 1.8.8 - mmxprs 2.2.0). Since the solution of

M CF path , M CF tree

and

M CF gener

is based on column generation,

the convergence of the algorithm can be slow for large size instances (this is the well-known tailing-o eect). Many techniques have been proposed in the literature to speed up column generation (see, e.g., [3, 19] and the references therein). In our implementation, we used the In-Out technique of [3]. At each iteration, we have a dual feasible vector (an interior point) and an exterior dual vector (the optimum of the dual problem). Then, instead of using the exterior dual vector to generate new columns, we use a convex combination of the interior dual vector and the exterior one.

This helps in nding "good" new columns (see [3] for

details). In our case, we took the convex combination

0.75

times the interior point +

0.25

times the exterior point to generate columns. Notice that the goal of this paper is not to compare stabilization techniques of column generation, but rather to evaluate the eciency of several formulations of the MCF problem.

That is why only the In-Out approach is

considered in our experiments. Thirteen instances have been generated. The characteristics of these instances are summarized in Tables 2 and 3.

I

denotes the number of the instance.

For each instance, the number of vertices destinations for each source and the number of arcs

|A|

|T (s)|

|V |,

the number of sources

|S|,

the number of

(we have used the same number for each source

are provided in Tables 2 and 3. The values of

a

and

b

s ∈ S)

are also

shown in Table 2 related to RMF instances (generated by the RMFGEN tool). The MCF formulations are mainly compared in terms of the computing times (in seconds) required to solve them. We also report the number of variables generated within the columngeneration algorithms (Gen. Vars), the number of non-zero variables in the optimal solutions obtained (Opt.

Vars) and the number of iterations, i.e., the number of times the master

problem is solved (Iterations). When the formulation did not provide a solution (because of exceeding available memory) we put a "-" instead of the result. Notice that the pricing algorithm in the column-generation approach used to solve

21

M CF path , M CF tree

and

M CF gener

is exactly the same: we use Dijkstra's algorithm to

compute a shortest-path tree for each source. In Table 4, we compare formulations

M CF agg , M CF path , M CF tree

and

M CF all

using

the RMF instances, whereas Table 5 is related to random graph instances. If we focus on the results related to instances 1 to 3, we can see that the resolutions based on the tree formulation are about two times faster than those based on the path formulation. This seems to be related to the number of generated variables which is smaller when the tree formulation is used.

However, even if fewer variables are generated in

M CF all ,

this

formulation seems the least ecient. In fact, the number of iterations needed to reach the optimal solution is very large when

M CF all

is considered.

For instances 2 and 3, the number of sources is reduced but the number of destinations per source is increased so that the total number of commodities remains approximately constant (so

|K|

is almost the same for instances 1, 2 and 3).

It appears that when the

number of sources is reduced while keeping the number of commodities constant, the tree formulation becomes more and more ecient (compared to the path formulation), with computing times almost two times smaller for instance 3.

When the tree formulation is

considered, a single variable somehow "aggregates" the information of a potentially large number of paths and the improvement is hence even more signicant when the number of destinations per source is large. We can point out that the aggregated arc-ow formulation has also the same behavior, for the exact same reasons. For instance 4, the number of sources

|S| is larger than for instance 3 while the number of

commodities per source is the same. We observe that the resolution with the tree formulation is then about

20 times faster than the one with the path formulation.

Notice that the number

of iterations in the path formulation case is larger than what we get with the tree formulation. One can also see that

M CF all

becomes more ecient than

M CF path .

When we consider instances with more vertices such as instance 5, the improvements due to the tree formulation are even more important.

M CF path .

22

M CF all

is also much better than

Results related to the larger size instances 6-7 conrm the tendency.

The path for-

mulation is unable to solve these instances because memory limits are reached.

The tree

formulation becomes more than 88 times faster than the aggregated arc-ow formulation for instance 7. The same conclusions are reached when the second type of data is considered. Table 5 clearly shows that the tree formulation outperforms the other formulations. The main dierence between the results of Table 4 and those of Table 5 seems to be the performance of instances,

M CF path

M CF path

compared to

M CF aggr .

is more dicult to solve than

In the RMF case, at least for large

M CF aggr ,

while the path formulation

outperforms the aggregated arc-ow formulation on the random graph instances. However, in all cases, the tree formulation gives the lowest computing times. The tree formulation is compared with some generic formulations of Section 3 in Tables 6 and 7. We consider two kinds of aggregation schemes: a 2-tree scheme scheme

M CF 4tr

(where a variable represents respectively

2

and

4

M CF 2tr

and a 4-tree

trees rooted at

2

and

dierent sources). Results related to the heuristic of Section 3 are presented in columns and

4

2tr

4tr.

Observe that the number of iterations related to

2tr

is generally larger than the number

of iterations of the tree formulation while the number of generated variables is smaller in the rst case. Roughly speaking, the more you aggregate, the smaller the number of generated columns and the larger the number of iterations. Moreover,

M CF 2tr

can outperform the tree formulation. This clearly implies that aggre-

gating demands by source and considering trees instead of paths is certainly a good strategy, but it is not necessarily the best strategy. The best aggregation strategy is a trade-o between the number of iterations (how many times the master problem is solved) and the number of columns generated (the size of the master problem). Observe that the best level of aggregation is not always the same. In fact, the increase of the instance size seems to enhance the relevance of such aggregation. However we cannot provide here neither a formal justication for such behavior nor denitive advice for general computation.

23

Finally, we present in Table 8 some results related to

M CF path

and

M CF tree

for in-

stances 1 to 5 when the In-Out approach is not used. In fact, we wanted to check whether the improved performance of the tree formulation compared to the path formulation is not simply due to the use of the In-Out approach. Table 8 clearly shows that much better than

M CF path .

M CF tree

is still

Moreover, by comparing Tables 8 and 4, one can see that the

In-Out technique drastically reduces computing times.

6 Conclusion In this paper, we studied some decomposition algorithms for the maximum concurrent ow problem. A generic model encompassing both path and tree models is proposed. We have shown that, perhaps somewhat surprisingly, this new model is indeed equivalent to the path-based model and is hence a valid model for the MCF problem. Due to the aggregation of many paths into single variables, the generic model can be much more ecient than the classical path model. For large size problems, aggregation by source seems to be a good choice. Further aggregations can also lead to more reductions in terms of computing time. Numerical experiments have also conrmed that more you aggregate, the fewer the generated columns and the larger the number of iterations. Generally speaking, nding the right level of aggregation in a large LP model is not an easy issue for which there is a denite answer: it is basically a matter of nding the right balance between the number of variables involved in the master problem and the number of columns that need to be generated in order to nd an optimal solution together with the eort that is spent for nding each new column.

The answer hence heavily depends on pure computational

capabilities and on the problem size. In our case, we can however provide a quite reasonable argument in favor of the tree formulation, namely the fact that we can separate a single tree variable with the same computational eort as for a single path whereas the tree variable embeds a whole set of paths. The generic model proposed for the maximum concurrent ow problem can obviously be generalized to other important multicommodity ow problems. An experimental study

24

would be helpful to evaluate the eciency of the generic formulation for these problems. When only one source is considered, we show that the problem can be solved even more eciently by a strongly polynomial-time combinatorial algorithm. The proposed algorithm is also able to compute a sparsest cut in the single-source case. One very important question that remains open is whether the single-source combinatorial algorithm can be extended to cover the more general case of multiple-source problems.

Acknowledgments We wish to thank the associate editor and the anonymous referees for many valuable comments and suggestions that have led to a substantially improved paper. We would also like to thank Professor A. Frangioni for bringing reference [14] to our attention.

References [1] R.K. Ahuja, T.L. Magnanti, and J.B. Orlin, Network ows: Theory, algorithms, and applications, Prentice-Hall, Upper Saddle River, NJ, 1993.

[2] S. Arora, S. Rao, and U. Vazirani, Expander ows, geometric embeddings and graph partitioning, J ACM 56 (2009).

[3] W. Ben-Ameur and J. Neto, Acceleration of cutting-plane and column generation algorithms: Applications to network design, Networks 49 (2007), 317.

[4] D. Bienstock, Potential function methods for approximatively solving linear programs: Theory and practice, CORE Lecture Series Monograph, 2001.

[5] D. Bienstock and O. Raskina, Asymptotic analysis of the ow deviation method for the maximum concurrent ow problem, Mathematical Programming Ser B 91 (2002), 479492.

[6] U. Derigs and W. Meier, Implementing Goldberg's max-ow-algorithm - a computational investigation, ZOR - Methods and Models of OR 33 (1989), 383403.

25

[7] J. Edmonds and R.M. Karp, Theoretical improvements in algorithmic eciency for network ow problem, J ACM 19 (1971), 248264.

[8] L. Fleischer, Approximating fractional multicommodity ow independent of the number of commodities, SIAM J Discr Math 13 (2000), 505520.

[9] N. Garg and J. Könemann, Faster and simpler algorithms for multicommodity ow and other fractional packing problems, SIAM J Comput 37 (2007), 630652.

[10] A.V. Goldberg, J.D. Oldham, S.A. Plotkin, and C. Stein, An implementation of a combinatorial approximation algorithm for minimum-cost multicommodity ow, Proc IPCO, Houston, Lecture Notes in Computer Science, Vol. 1412, Springer, 1998, pp. 338352.

[11] O. Günlük, On the min-cut max-ow ratio for multicommodity ows, SIAM J Discr Math 21 (2007), 115.

[12] M.T. Hajiaghayi and T. Leighton, On the max-ow min-cut ratio for directed multicommodity ows, Theor Comput Sci 352 (2006), 318321.

[13] T.C. Hu, Multi-commodity network ows, Operations Research 11 (1963), 344360.

[14] K.L. Jones, I.J. Lustig, J.M. Farvolden, and W.B. Powell, Multicommodity network ows:

The impact of formulation on decomposition, Mathematical Programming 62

(1993), 95117.

[15] A. Jüttner, Optimization with additional variables and constraints, Operations Research Letters 33 (2005), 305311.

[16] G. Karakostas, Faster approximation schemes for fractional multicommodity ow problems, ACM Transactions on Algorithms 4 (2008), 117.

[17] T. Leighton and S. Rao, Multicommodity max-ow min-cut theorems and their use in designing approximation algorithms, J ACM 46 (1999),787832.

[18] N. Linial, E. London, and Y. Rabinovich, The geometry of graphs and some of its algorithmic applications, Combinatorica 15 (1995), 215245.

26

[19] M.E. Lübbecke and J. Desrosiers, Selected Topics in Column Generation, Oper Res 53 (2005), 10071023.

[20] P. Mahey, Decomposition methods for mathematical programming, Handbook of Applied Optimization, Pardalos and Resende (Editors), Oxford U. Press, 2002, pp. 1126.

[21] D.W. Matula and F. Shahrokhi, The maximum concurrent ow problem and sparsest cuts, Technical report, Southern Methodist Univ, Dallas, 1986.

[22] C.H. Norton, S.A. Plotkin, and E. Tardos, Using separation algorithms in xed dimension, Journal of Algorithms 13 (1992), 7998.

[23] H. Okamura and P.D. Seymour, Multicommodity ows in planar graphs, J Combin Theory Ser B 31 (1981), 7581.

[24] S. Plotkin and E. Tardos, Improved bounds on the max-ow min-cut ratio for multicommodity ows, Proc 25th ACM Symposium on Theory of Computing, San Diego, CA, 1993, pp. 691697.

[25] A. Schrijver, Combinatorial optimization. Polyhedra and eciency, Algorithms and Combinatorics, Vol 24, Springer, 2003.

[26] D.B. Shmoys, Cut problems and their Application to divide-and-conquer", Approximation Algorithms for NP-Hard Problems, D.S. Hochbaum (Editor), PWS Publishing Company, 1997, pp. 192235.

[27] E. Tardos, A strongly polynomial algorithm for solving combinatorial linear programs, Operations research 34 (1986), 250256.

[28] S. Tragoudas, Improved approximations for the min-cut max-ow ratio and the ux, Mathematical Systems Theory 29 (1996), 157167.

27

directed graph

V

set of vertices

A

set of arcs

v − (a), v + (a)

ca

tail/head of arc

capacity of arc

incoming/outgoing arcs of subset

U

δ − (v), δ + (v)

incoming/outgoing arcs of vertex

v

a

k ∈ K,

paths and trees

S, T (s)

set of sources, set of destinations for a source

dk , dij

demand (value) of commodity

P k , P ij

set of paths for commodity

Ti

set of trees rooted at vertex

Vaτ

set of vertices of

T (i)

k,

of vertices

k

source, destination of commodity

k,

between

between

i

i

s∈S

and

and

j

j

i

belonging to the subtree of

lenkp (µ)

length of path

lenst τ (µ)

length of the path connecting

p

a

δ − (U ), δ + (U )

set of commodities

sk , tk

G = (V, A)

for commodity

s

k

with weights

to

t

in tree

τ

τ

µa

rooted at

v + (a)

on the arcs

with weights

µa

on the arcs

ow variables and dual variables

fak , gah

ow of commodity

k,

φkp , fa

ow of commodity

k

λkp , βτi

proportion of ow of commodity

of the aggregated commodity on path

p,

the total ow on arc

k

on path

µa

dual of capacity constraints (13) and (19)

ν k , ϕs

dual of demand constraints (14) and (20)

Table 1: Main notation.

28

h ∈ K agg ,

p,

on tree

a τ ∈Ti

on arc

a

I

|V |

|S|

|T (s)|

a

b

|A|

1

125

125

31

5

5

600

2

125

63

62

5

5

600

3

125

31

124

5

5

600

4

125

125

124

5

5

600

5

216

216

215

6

6

1080

6

343

343

342

7

7

1764

7

512

512

511

8

8

2688

Table 2: Characteristics of the rst seven RMF instances.

I

|V |

|S|

|T (s)|

|A|

8

180

180

179

2000

9

180

180

179

2500

10

180

180

179

3000

11

250

250

249

2000

12

250

250

249

2500

13

250

250

249

3000

Table 3: Characteristics of the six random graph instances.

29

CPU time (s)

Gen. Vars

Opt. Vars

Iterations

I

agg

path

tree

all

path

tree

all

path

tree

all

path

tree

all

1

146

32

20

326

8309

1273

338

3964

206

85

42

18

338

2

62

25

11

163

9252

798

287

3972

125

67

39

21

287

3

31

20

9

54

9464

534

179

3964

96

41

32

32

179

4

229

433

19

234

38108

1376

263

15693

190

73

45

14

263

5

3162

26927

341

3171

126389

3615

598

46855

386

150

56

29

598

6

28430

-

1409

-

-

5367

-

-

544

-

-

22

-

7

310590

-

3526

-

-

7621

-

-

858

-

-

23

-

Table 4: Comparison of

M CF agg , M CF path , M CF tree

CPU time (s)

and

M CF all :

Gen. Vars

RMF instances.

Opt. Vars

Iterations

I

agg

path

tree

all

path

tree

all

path

tree

all

path

tree

all

8

20537

263

39

1310

65150

1973

343

32560

257

100

31

13

343

9

32347

1257

89

4876

71709

2655

669

32689

341

172

50

17

669

10

85980

3036

515

-

80944

3577

-

33131

775

-

52

24

-

11

16174

10002

220

-

160210

3325

-

62731

588

-

32

15

-

12

30973

32380

475

-

193545

3699

-

63120

766

-

32

17

-

13

172018

47294

1545

-

241971

4856

-

62903

1103

-

46

24

-

Table 5:

Comparison of

M CF agg , M CF path , M CF tree

instances.

30

and

M CF all :

random graph

CPU time (s)

Gen. Vars

Opt. Vars

Iterations

I

tree

2tr

4tr

tree

2tr

4tr

tree

2tr

4tr

tree

2tr

4tr

1

20

18

28

1273

947

794

206

153

120

18

19

29

2

11

11

15

798

549

450

96

108

81

21

23

32

3

9

13

29

534

459

394

96

81

68

32

40

53

4

19

18

26

1376

905

719

190

127

95

14

17

25

5

341

311

360

3615

2502

1955

386

290

222

29

28

42

6

1409

1301

1444

5367

3856

2444

544

347

254

22

28

32

7

3526

2701

3453

7621

4501

3524

858

573

424

23

23

33

Table 6: Comparison of

CPU time (s)

M CF tree , M CF 2tr

and

Gen. Vars

M CF 4tr :

RMF instances.

Opt. Vars

Iterations

I

tree

2tr

4tr

tree

2tr

4tr

tree

2tr

4tr

tree

2tr

4tr

8

39

29

42

1973

1071

759

257

188

100

13

12

17

9

89

72

83

2655

1529

1010

341

258

187

17

18

23

10

515

429

819

3577

2456

1950

775

647

504

24

27

44

11

220

180

314

3325

2181

1560

588

389

389

15

18

25

12

475

460

633

3699

2676

1888

766

595

509

17

22

30

13

1545

1153

2844

4856

3309

2498

1103

856

767

24

28

40

Table 7:

Comparison of

M CF tree , M CF 2tr

31

and

M CF 4tr :

random graph instances.

CPU time (s)

Gen. Vars

Opt. Vars

Iterations

I

path

tree

path

tree

path

tree

path

tree

1

251

107

33365

5375

4016

246

116

89

2

333

83

39818

3588

4047

188

113

95

3

353

75

40010

2031

3988

142

104

106

4

5195

451

116243

8655

15747

254

99

103

5

95205

4569

362838

24013

46870

438

129

157

Table 8: Comparison between path and tree formulations when the In-Out approach is not used: RMF instances.

32