An efficient approximation algorithm for the survivable ...math.mit.edu/~goemans/PAPERS/GabowGoemansWilliamson-1998-… · An efficient approximation algorithm for the survivable

Mathematical Programming 82 (1998) 1340

An efficient approximation algorithm for the survivable network design problem 1

Harold N. Gabow a,2, Michel X. Goemans b,3, David P. Williamson c,.,4

a University of Colorado, Campus Box 430, Boulder, CO 80309, USA b M.LT. Room 2-382, 77 Massachusetts Avenue, Cambridge, MA 02139, USA

c IBM TJ Watson Research Center, P.O. Box 218, Yorktown Heights, N Y 10598, USA

Received 3 July 1995; accepted 15 September 1996

Abstract

The survivable network design problem (SNDP) is to construct a minimum-cost subgraph satisfying certain given edge-connectivity requirements. The first polynomial-t ime approximation algorithm was given by Williamson et al. (Combinatorica 15 (1995) 435454) . This paper gives an improved version that is more efficient. Consider a graph of n vertices and connectivity requirements that are at most k. Both algorithms find a solution that is within a factor 2k - 1 of optimal for k ~> 2 and a factor 2 of optimal for k 1. Our algorithm improves the time from O(k3n 4) to O(k2n2 + kn21~dg log n). Our algorithm shares features with those of Wil- liamson et al. (Combinatorica 15 (1995) 435454) but also differs from it at a high level, ne- cessitating a different analysis of correctness and accuracy; our analysis is based on a combinatorial characterization of the " redundant" edges. Several other ideas are introduced to gain efficiency. These include a generalization of Padberg and Rao 's characterization of minimum odd cuts, use of a representation of all minimum (s, t) cuts in a network, and a new priority queue system. The latter also improves the efficiency of the approximation algorithm of Goemans and Williamson (SIAM Journal on Computing 24 (1995) 296 317) for constrained forest problems such as minimum-weight matching, generalized Steiner trees and others. © 1998 The Mathematical Programming Society, Inc. Published by Elsevier Science B.V.

* Corresponding author. E-mail: [email protected]. i A preliminary version of this paper has appeared in the Proceedings of the Third Mathematical

Programming Society Conference on Integer Programming and Combinatorial Optimization, 1993, pp. 57-74.

2 E-mail: [email protected]. Research supported in part by NSF Grant No. CCR-9215199 and AT & T Bell Laboratories.

3 E-mail: [email protected]. Research supported in part by Air Force contracts AFOSR-89-0271 and F49620-92-J-0125 and DARPA contracts N00014-89-J-1988 and N00014-92-1799.

4 This research was performed while the author was a graduate student at MIT. Research supported by an NSF Graduate Fellowship, Air Force contract F49620-92-J-0125, DARPA contracts N00014-89-J- 1988 and N00014-92-J-1799, and AT & T Bell Laboratories.

0025-5610/98/$19.00 © 1998 The mathematical Programming Society, Inc. Published by Elsevier Science B.V. P H S 0 0 2 5 - 5 6 1 0 ( 9 7 ) 0 0 0 8 7 - 7

14 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13-40

Keywords: N e t w o r k design; A p p r o x i m a t i o n a lgo r i t hm; S te iner tree

1. Introduction

In the survivable network design problem (SNDP) we are given an undirected graph G = (V, E), a non-negative cost ce for every edge e, and a non-negative connectivity requirement rij for every (unordered) pair of vertices i,j. We must find a minimum- cost subgraph in which each pair of vertices i ,j is joined by at least ril edge-disjoint paths. SNDP is NP-complete since the Steiner tree problem is a special case. An im- portant practical application arises in the design of fiber-optic telecommunication networks. In that context the most interesting case is when rij is of the form min(ri, rj) for some vector (ri)icv of connectivity types, with each r~ ~ {0, 1,2}. Ver- tices with ri = 1 represent customers; vertices with r/ 2 represent switching stations that need to be protected from single edge failures, while vertices with r~ 0 are op- tional sites. For a thorough discussion of the problem and a survey of existing results, the reader is referred to the survey paper by Gr6tschel et al. [10].

A heuristic that gives a solution guaranteed to be within a factor c~ ~> 1 of optimal has a performance guarantee of c~. If in addition the heuristic runs in polynomial time it is called an (~)-approximation algorithm. The first approximation algorithm for the general SNDP was developed by Williamson et al. [20]. Before this no approximation algorithm was known even for the case r~/= min(r~, rj), ri C {0, 1,2}. The previously known special-case SNDP approximation algorithms are listed in Table 1. Throughout this paper n and m denote the number of vertices and edges of the given graph. For simplicity the time bounds in the table assume dense graphs, m -- ®(n2). Agrawal et al. [1] and Goemans and Williamson [8], building on the work of Goe- mans and Bertsimas [7], have described an approximation algorithm for a variant of SNDP in which an edge can be selected several times. This version of the problem, however, appears to be easier to approximate.

Table 1 Previous work on special cases of SNDP

Problem Requirements Performance guarantee Time References

Steiner tree ri c {0, 1} 2 O(n 2) [151 1116 O(n 35) [21] 16/9 0 (n 5 ) [2]

Generalized Steiner tree r/g E {0, 1} 2 O(n21ogn) [1] [8]

2-edge connected subgraph ri = 2 3 O(n 2) [3] k-edge connected subgraph ri - k 2 O(kn 3 logn) [12] Generalized Steiner 2-edge- r~j E {0, 2} 3 O(n 2 logn) [13]

connected subgraph

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~40 15

This paper presents an improved version of the approximation algorithm of [20]. Both algorithms apply to a family of integer programs defined by proper functions f . A function f : 2 v -+ N is called proper if: • [Symmetry] f ( S ) = f ( V - S) for all S C_ V; and • [Maximality] If A and B are disjoint, then f ( A U B) <~ m a x { f ( A ) , f ( B ) } .

We will also assume that f((0) = 0 for all proper functionsf. Given an undirected graph G = (V, E), the family of integer programs that can be approximated is formu- lated by

(IP) min ZCeXe eGE

s.t. x(6(S)) >~ f ( S ) , S C V,

x~ C {0, 1}, e C E ,

where 6(S) denotes the coboundary of S (the set of edges with exactly one endpoint in S) and x(F) = ~eEF Xe" SNDP is given by the proper function f ( S ) = max~cs,jcsr~j. The algorithms of Williamson et al. [20] and this paper both achieve this result.

Theorem 1.1. I f the proper function f takes only l non-zero distinct values 0 : DO < Pl < P2 < "'" < Pl, then there is an approximation algorithm for (IP) with performance guarantee at most

l

2 ~ ~ { ~ ( P i - Pi-1) , i-1

where ~ is the harmonic function ~ ( k ) = 1 + 1 + ½ + . . . + ~. i f pl = 1 and l >~ 2 then the performance guarantee improves by one unit.

In the rest of this paper, fmax denotes the largest requirement, f~ax = maxs f (S ) . Thus the performance guarantee of Theorem 1.1 is at most 2f,lax or, more precisely, 2fmax -- 1 whenever f~ax ~> 2. Furthermore, both algorithms prove that the factor 2fmax -- 1 (or 2 iffmax = 1) bounds the gap between (IP) and its linear programming relaxation. We will assume that we are dealing with Simple graphs so that fmax ~< n, although our results can be easily extended to the case of multigraphs.

The main result of this paper is an algorithm that achieves the accuracy of The- orem 1.1 efficiently: the time bound of Williamson et al. [20] for SNDP, O0Cm~axn3 4),

2 2 is improved to O(J~axn +f~,xn=x/log log n)). To state our specific contributions, we first briefly sketch the approximation algo-

rithm. It proceeds in fma~ phases. Each phase finds a low-cost augmentation to the current solution. Let Fp ~ denote the edges chosen in the first p - 1 phases, and let 6A(S) denote A N cS(S) for A c_ E. Then in phase p we find a set of edges F c E - F p _ l such that whenever f ( S ) >~p and ]66 1(S)1 = p - 1, then I(~F(S) I ~ 1. We then set Fp = F p _ I U F so that we maintain the invariant that 16Fp (S)] ~> min(f(S) ,p) for all subsets S. Thus the final set Fj;,,~ is a feasible solution to the integer program (IP).

16 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~tO

The augmentation in each phase can be viewed as finding a low-cost solution to

~ CeXe e~Eh

s.t x(6(S)) >~ h(S), S c V,

xe C {0, 1}, e C E h ,

where Eh = E - F p 1 and h(S) = 1 i f f f (S) ~>p and IC~F; I(S)[ = p - 1, and h(S) = 0 otherwise. Williamson et al. [20] showed how to find such a solution if the function h is uncrossable; i.e., if h(A) = h(B) = 1, then either h(A - B) = h(B - A) = 1, or h(A U B) = h(A • B) = 1. They then showed that the function h given above is uncrossable. Their algorithms for finding such a solution works in two steps. The first step uses a primal dual algorithm which constructs a set of edges F that is a feasible solution to (IPh) while simultaneously constructing a feasible solution to the dual of the linear programming relaxation of (1Ph). The second step of the algorithm is a "clean-up step". It removes certain unnecessary edges from F.

We introduce an alternate algorithm to find low-cost solutions to (IPh) for uncrossable functions. The algorithms of Williamson et al. [20] and this paper use the same procedure for the first step to initialize F, but differ in the clean-up step. The clean- up step is crucial, as no finite performance guarantee can be achieved without a clean-up step. For example, on the shortest s- t path problem their algorithm emulates Dijkstra's algorithm, and the edges of the shortest path tree not on the s- t path must be removed to guarantee low cost. In [20] both steps of the algorithm use the same amount of time. The clean-up step is the bottleneck against speeding this up; it checks the feasibility of O(n) edge sets. We circumvent this problem by giving a combinatorial characterization of a set of edges which may be safely removed. These edges can be easily identified by gathering information in the first step of the algorithm. The characterization leads to a new, more efficient clean-up step and a different proof of the performance guarantee of the algorithm. Our clean-up step is no longer the bottleneck even in the improved algorithm: it uses O(n) time per phase.

The remaining contributions of this paper concern the efficient implementation of the first step of a phase. There are several new ideas. To decide which edges to add to F requires identifying certain "active sets". The high-level algorithm does not indi- cate how to do this in polynomial time. Williamson et al. [20] show how to find the active sets by solving O(n 2) network flow problems. We identify active sets more efficiently using two ideas from flow theory. First we show the Gomory -Hu cut tree gives a characterization of a feasible solution to (IP). This generalizes Padberg and Rao's characterization of a minimum T-cut in terms of the Gomory -Hu tree [16], since T-cuts correspond to a proper function. Next we combine the Gomory -Hu tree with the representation of Picard and Queyranne for all minimum (s, t) cuts of a network [17]. This allows efficient identification of the active sets. Combining these two ideas has been previously suggested by Gusfield and Naor [11]. We gain further

the integer program

(IPh) min

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13-40 17

efficiency by showing that the special structure of SNDP allows faster location of the active sets in the representation.

As the last ingredient in an efficient algorithm, we improve the implementation of the rule for selecting the next edge to add to F. This edge-choice rule (also used in [20]) is similar to the rule in the algorithm of Goemans and Williamson [8]. Goemans and Williamson present approximation algorithms for minimum-weight matching (with the triangle inequality), T-joins, Steiner trees and generalized Steiner trees, and a number of other problems. All these algorithms have performance guarantee 2 and run in time O(n 2 log n). Our implementation improves this time bound to O(n(n + x/m log log n)). The idea of the implementation is to avoid work on irrelevant edges. Independently, Klein [14] gives an O(nx/N log n) time implementation using a new data structure.

Putting the pieces together gives the following results. For SNDP with requirements rij ~<fmax the performance guarantee is 2Jm~x- 1 for f ~ x ~> 2 and 2 for fm~x = 1. For fmax = O(1) the running time is O(n(n + x/m log log n)); more gener- ally the time is O(fm2ax n3 +fmaxnv/m log log n). We also give a time bound for general proper functions f (assuming an oracle for f ) ; this bound is o(fZax n3 + fnaxnZp) where p is the time taken by an oracle that computes the function f . More precise time bounds are given in Section 5.

The rest of this paper is organized as follows. Section 2 presents the high-level algorithm. Section 3 proves it finds a feasible solution and Section 4 proves the performance guarantee. Section 5 gives the implementation details, in a number of subsections.

2. The main algorithm

This section summarizes the overall algorithm, and our new algorithm for finding low-cost solutions to (IPh) for uncrossable functions; the algorithms are given in Figs. 1 and 2, respectively. We call the algorithm for uncrossable functions Uncross- able. To make the algorithm somewhat simpler to understand, a simulated run of Uncrossable is represented in Fig. 5 with comments later in the text.

Input: An undirected gruph G = (V, E), edge costs c. _> O, a proper function f , und fm.x = ma~s f ( S ) Output: A set of edges Ff~.~ feasible for ( IP) I F0 ~-- 0

2 For p ~-- 1 to .fm.x

3 Comment: Begin phase p.

1 iff(S)>pand [6F,_,(S)I=p--I 4 h~(S) ~-- 0 otherwise

5 B p * - E - F p _ l

6 F ' 4-- UNOI%OSSABLE(V, Ep, C, hp)

7 Fp~-Fp-~UF'

8 Comment: End phase p.

9 Output Fy . . .

Fig. 1. The main algorithm.

18 H.N. Gabow et aL / Mathemat ical Programming 82 (1998) 13-40

Input: An undirected graph G = (If, Eh), edge costs e~ ~ O, and an unerossable function h Output: A set of edges F ' feasible for (IPh) 1 F*- -$

2 i*- -0

3 d(,,) ~ 0 for ~ v e V

4 Comment: Implicitly set Ys ~ 0 for all S C V

5 C ~-- all active sets C (minimM violated sets).

6 While ICl > 0

7 i * - - i + l

8 Comment: Begin iteration i.

9 Comment: Edge selection step.

10 For nil *~ 6 C E C, increase d(v) uniformly by • until some edge el = (u, v) 6 g n satisfies d ( u ) + d(v) = e~ for ei 6 6(G) of some G E C.

11 Comment: Implicitly set yc +-- Vc + • ]or all G 6 C.

12 F ~- Y U {e~}

13 Comment: Edge addition step.

14 Update C,

15 Comment: End iteration i.

lg Comment: Edge clean-up step.

17 F ' *-- F

18 Let all sets that were active during this phase be unmarked. Mark the set V.

19 For ] +- i downto 1

20 Comment: O(e), A(e), and special edges are defined in the tart.

21 If ej is speciM and G(e j ) is unmarked and 5p,(A(ej)) _D 6F,(G(ej)) then

22 F' 4- F' - {ej}

23 Mark C(e j )

24 Output F'

F i g . 2. T h e u n c r o s s a b l e a l g o r i t h m .

Recall the overall structure of the algorithm, as given in Fig. 1: there are

fmax = maxs f ( S ) phases indexed by p = 1 , . . . ,fmax. Phase p produces a set Fp such that I3Fp(S)I ~> min(f(S),p) . ~ .... is feasible for (IP). In phase p we call Uncrossable with the edge set Eh = E - b), 1 and with the function h(S) = 1 iff 13Fp 1 ( S ) I = P - - 1 and f (S)>~p. Recall that we call a function h uncrossable if whenever h(A) = h(B) = l, then either h(A - B) - h ( B - A) --1, o r h ( A U B ) = h ( A N B ) = - I . This function was proven to be uncrossable by Williamson et al. [20].

For the rest of this paper, we will assume that the uncrossable functions in Un- crossable are symmetric: that is, h(S) = h(V - S) for all S C V. Since proper functions f are symmetric, the uncrossable function used in phase p is always symmetric. Details about using Uncrossable with functions that are not symmetric can be found in [19]; some proofs and arguments are slightly different.

As discussed in Section 1, the algorithm Uncrossable has two steps. The first step produces a set of edges F and consists of a number of iterations, each iteration consisting of an edge selection and edge addition step. The second step is the clean-up step. It removes edges from F. We now describe the two steps in detail. The first step initializes F to be empty. At any point, a set S is called violated if IC~F(S) I < h(S); that is, if h(S) = 1 but 6F(S) = 9. A set S is active if it is a minimal violated set (minimal with respect to inclusion). The first step maintains the family of active sets ~. Note

H.N, Gabow et al. / Mathematical Programming 82 (1998) 13~40 19

that in terms of our algorithm for proper functions, a set S is violated in the call to

Uncrossable in phase p i f I(~Fp_IUF(S)I = p - - 1 and f ( S ) >~ p.

The violated sets have the following property, which was proven in [20].

Lemrna 2,1 (Williamson et al. [20]). I f A and B are violated sets at any point in

Uncrossable, then either A N B and A U B are violated or A - B and B - A are violated.

Proof. Since A and B are violated, we know that h(A) = h(B) = 1. By the properties ofuncrossable functions, either h(A U B) = h(A n B) -= 1 or h(A - B) = h(B - A) = 1.

Suppose the former is true. By the submodulari ty of 6, we know that

IC~F(A)I Jr 16F(B)I /> [6F(A NB)[ + 16F(A UB)I. Since Ic]y(A)l = IC]F(B)I = 0, it must be the case that ](SF(A N B)I = 16F(A U B)I ---- 0, and A N B and A U B are violated.

I f the latter case is true, then a similar argument follows since it is also the case

that b6r(m)k + 16r(B)l >~ 16F(A B)L + q6F(B- A)I. []

An immediate corollary of this lemma is that all active sets are disjoint. Another corollary is the following. We say a set A crosses B irA N B ~ ~, but A ~ B and B ~ A.

Corollary 2.2. No violated set crosses any active set.

In each iteration, an edge, e E Eh is selected from the coboundary of some currently active set C and e is added to F. The edge e can be in the coboundary of either 1 or 2 active sets; e is a 1-edge in the first case and a 2-edge in the second case. The edge selection step chooses e, based on values of certain dual variables. The edge addition step adds e to F. This necessitates updating the family of active sets cg, since the active set(s) having e in their coboundary are no longer violated. Moreover a new active set may be created. Such a new active set must contain both ends of e. The first step terminates when no active sets remain.

Another consequence of Lemma 2.1 is the following. A laminar family of sets 5 ° is one such that if A, B C 5 ~ and A N B ¢ {3, then either A C_ B or B c A; that is, if A, B C J , then A and B do not cross.

Corollary 2.3. Let Uc~ denote the set o f all active sets Jormed over all iterations. Then

UCg is a laminar family.

The idea behind the edge selection step is to implicitly maintain a feasible solution y to the dual of the linear programming relaxation of (IPh) formed by replacing the

constraints Xe E {0, 1} with xe ~> 0. This dual is as follows:

(Dh) max

s , t .

ScV

Z ys~c~ , S: eE6(S)

ys>~O, S C V .

e C Eh,


Initially y = 0. Each iteration o f the algori thm implicitly increases Yc for each active set C Ccg by a value e which is as large as possible wi thout violating the inequality

ys ~< ce for any edge e E Eh. This makes an inequality tight for some edge e c Eh in

the coboundary o f some active set; this edge e is then chosen to be added to F. This

feasible dual solution is used to prove the performance guarantee o f the algorithm.

Instead of keeping track of the dual solution y, our algori thm only maintains a

variable d(u) -- ~s: ,csYs for each u c V. Then increasing yc for each active set C C c~ by the largest ~ possible wi thout violating ~ y s <~ce for any edge e E Eh

becomes equivalent to increasing the variables d(u) for u c C E c~ by the largest e possible without violating d(u) + d(v) ~ c,~ for e -- (u, v) C Eh, e in the coboundary

o f some active C. Thus if a(u) = 1 if u is in an active set, a(u) = 0 otherwise, then

e = min c~i - d(i) - d(j) a(i) +.(j)

Before we define the new edge clean-up stage, we define some notat ion and we try

to provide an intuitive feel for the concepts involved. Suppose for a momen t that the

uncrossable function h under considerat ion is such that no new active sets are ever created: we have some initial collection ~ of active sets, and in each iteration we se-

lect some edge in the cobounda ry o f at least one, and at most two, active sets f rom ~.

Once an edge in the coboundary o f an active C is selected, then C is no longer vio-

lated, and hence no longer active. Thus in this case, there will be at most Icgl itera-

tions of the edge addit ion step. Let F be the set o f edges added during these

iterations.

Still assuming that no new active sets are created, F is a forest in the graph with

each active set contracted to a single node plus some other nodes (see Fig. 3). Con-

sider also how each tree o f this forest "g rows" as edges o f F are added. Each current-

ly existing tree adds a new node by adding a 1-edge which has one endpoint in a

currently active set (the new node) and the other in a set that was active in some

previous iteration (a node in the growing component) ; see Fig. 4, in which edge ei

was added in the ith iteration. Notice that we never add edges whose endpoints

are both in previously active sets, and thus we never link two trees. F r o m this obser-

vation, it is not hard to see that 2-edges must always start growing a new tree (e.g. el). A new tree can also start growing by a 1-edge which has one endpoint in a currently

e3 e5

Fig. 3. A forest on active sets. Each circle represents an active set before any edge was added.


© % Fig. 4. Growing a tree of the forest. The thin circles represent previously active sets; the thick circle represents an active set.

active set and the other endpoint which is not in any current or previously active set

(e.g. e3). The edges that particularly interest us for the new edge clean-up step are 1-edges e

such that the edges added after e form a tree spanning precisely the sets active imme-

diately before the addition of e. We call these edges special edges, and we define them

more formally below. In Fig. 3, e3 and es are special edges. The other edges are not

special edges: for example, e4 is not a special edge because es contains an endpoint in a set that is not active just before e4 is added. We will show that special edges have a

nice combinatorial structure such that we can remove some of them and simulta-

neously ensure a good performance guarantee and maintain feasibility.

To generalize this concept to the case where new active sets are formed, we partition

the edges and the active sets. Let U~ be the collection of all active sets formed over all iterations of the algorithm, plus the set V. Recall from Corollary 2.3 that UC8 is lam-

inar. We define a tree 3- based on U(~, with one vertex Vc for each C c UCg. Thus we

make Vc a parent of vD in the tree ~Y- if C is the smallest set in Ucg that properly contains

D. Let ~(C) denote the collection of sets corresponding to the children ofvc in 3-. The

collection ~(C) can be thought of as an equivalence class of active sets. For edge e, let

C(e) denote the smallest set C E UCg that contains both endpoints of e. The set of all

edges o f F for which C(e) = C is denoted Fc. The edges in Fc can be thought of as an

equivalence class of the edges o fF . The behavior of the edges Fc on the active sets in

~(C) will now be as in the case above in which no new active sets are formed. Let ~4(e) denote the sets in ~(C(e)) that are active just before edge e is selected.

We make the following observations.

Observation 2.4. For any vertex Vc in ,Y-, all edges in Fc must be selected before any edge in 6(C) is selected.

Proof. Suppose not, and at some iteration an edge in 6(C) is selected before some

edge in Fc. Since not all edges in Fc have been selected, some C I c C must be active. But since an edge in 6(C) is selected, C will never become an active set, a contradiction. []

Observation 2.5. For tke first edge e in Fc selected, ~ ( e ) = ~(C(e)) .

22 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13 40

Proof. I f some set S E ~ ( C ( e ) ) is no t active, then some edge e ~ has been selected from

6(S) prior to edge e. If C(e') ¢ C(e), then it must be the case that e' E 6(C(e)), which contradicts the observation above. []

We can now formally define the special edges. Say that an edge set H forms a

spanning tree on a family of disjoint vertex sets {Ci}ie_l if each endpoin t of each edge

in H lies in one of the C,. and H forms a spann ing tree on the graph with each Ci con-

tracted to a node. Then e is special if it is a 1-edge, and the edges added to Fc(e) after e

form a spanning tree on the sets in ~#(e).

We illustrate the concept in its full generality in Fig. 5. Frames 1 9 correspond to

the edge addi t ion stage, frames 13 16 to the clean-up step, while the final solut ion is

0 ~ 1 ~ ~ ~ ~ ~ 2 ~ 0 ~ ~ 0 ~

® • °

c 1 ® @ °

• ® ®

®

@

• •

®

r i l l

= ° 12 ® °

®

® ® ® ® C3 C 3 1 C 3 (:213 C3 C3 C ~ Z ~ C3 0 C3 0 3 ~ C3 C )

C3 C 3 5 C 3 C3 C3 o cD6o

• o

° ®

m m , m

O Q

"I o

I Q CD

0 o7(:D (::3 o

i:i" m | | J J | J m | m

mmmem,~em,~ul, m

.-. ° °

l °3 c ~ o

D ® ®

I:~ C D 4 ~ O C~

63

f

i i

®

( 4 1 m m m l m

-_ll:lt~_ii_~lM~

c = B ,

-- °7 - ,

I " -i I !

°

~ | | | | i

° = " I

I ° °

Q 9 e"~ lad CD m m ' i ' m l l l [ l l ~ l m

0 0 o 1 1 o 0 o e I

= = • ~"2 e 3

°

C:] C) IICD (:~ (D

o Cal2O c:~ o

m m

O O 1 3 0 ~ O

2' °7° i 2

e5 c(e71

O O 1 3 0 O O

c6 i ~ e 4

Fig. 5. Simulation

O O 1 5 0 O O

F ~ ° t °2 e 5

5J

e6

o C:~l~C::~ 0 c:~

run of the algorithm.

~ 1 6 ~ C3 ~ [

o eC(e l e4

~ 1 6 C ~ c~ c3 I-

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~tO 23

depicted in frame 11. In frames 1 9, the edges correspond to the edges of F while the rounded boxes represent the active sets. In the figure, only edges e4 and e8 are 2-edges, the others being 1-edges. The special edges in the figure are el, es, e6 and e7. The edge e2 is not special because e4 is a 2-edge (and hence forms a new tree on the sets of • ~¢(e2)). The edge e3 is not special because e5 has an endpoint not in one of the sets of ~ (e3 ) .

The edge clean-up step is given in the algorithm in Fig. 2. It scans the edges o f F in the reverse order of their selection in the edge addition stage. Let A (e) denote the union of the sets in ~4(e); that is, A(e) = [,-Jce~(el C. The edge clean-up step removes edge e from F i f e is special, no other edge of Fe(i~has already been removed, and all remaining edges o f F in 6(C(e)) are also in 6(A (e)). It does not remove e if C(e) = V. To keep track of whether an edge of Fc(e) has already been removed, the algorithm marks C(e) if edge e is removed. We illustrate the clean-up step in frames 13 16 of Fig. 5. Recall that the special edges are el, es, e6 and e7. Frames 13 16 correspond to the situation just before the possible removal of edge e7, e6, e5 and el, respectively. In the frame corresponding to ei, the vertices in A (ei) are represented in white. Edge e7 is removed since es C c$(A(e7)). Edge e 6 is not removed since es ~ c$(A(e6)). Although e 7 ¢ (~(A(c5)), edge e5 is removed since e7 was previously removed. Edge el is not removed since e5 c C(el) has already been removed. The resulting forest is represented in frame 11.

3. Correctness

This section proves the set F' returned by Uncrossable is feasible for (IPh).

Theorem 3.1. The edge set U remaining after the edge clean-up step is a feasible solution for (IPh).

Proof. The edge addition stage terminates with no active sets, and thus no violated sets. So we need only prove that the clean-up step maintains feasibility. Assume it does not. Suppose F ~ is feasible for (IPh) but U - e is not, and the clean-up step removes e from U. The situation just before the removal of e is illustrated in Fig. 6. Let C = C(e). By the definition of the clean-up step, C ¢ V. Let S be a set violated by F' - e. Let Ie be the iteration in which edge e is added. The set S was violated in iteration Ie because of the ordering of the clean-up step.

Notice that all sets in ~¢(e) must also be violated in iteration Ie, by the definition of s~C(e). By Corollary 2.2, S does not cross any set in ~4(e). In fact we can show that either A (e) C S or A (e) C~ S = (3: because no edge of Fc has been removed so far in the clean-up process, the edges of Fc added after e form a spanning tree on the family d ( e ) . Thus if S crosses A(e) but not any set in s~C(e), it would intersect an edge of Fc added after e, contradicting the fact that S is violated.

We now assume that A(e) C_ S: if A(e) n S : 0, then by the symmetry of the uncrossable function h, V - S is also violated and we replace S with V - S. Since

24 H . N . Gabow et al. / Ma themat i ca l Programming 82 (1998) 13-40

C

Fig. 6. Notation used in the proof of Theorem 3.1.

C ¢ V, the set C, as well as S, is violated in iteration I~. By Lemma 2.1, either

C - S and S - C are violated or C n S and C U S are violated in iteration It,. How- ever C - S cannot contain an active set, so it is not violated. Thus C U S is violated in iteration l~. Since it was not violated before e was removed, F ' contains an edge

with exactly one endpoint in V - (C U S). The edge ~ is not in the coboundary of S since 6F'(S) = {e} and e ¢ ~ (since e has both endpoints in C). Thus the other endpoint of ~ is in C - S. On the one hand this implies g ~ c~(C(e)); on the other it implies ~ ~ 6(A(e)). But this contradicts the removal of e in the clean-up step. D.

4. Proof of the performance guarantee

Williamson et al. [20] show that the proof of the performance guarantee (Theorem

1.1) reduces to the proof of a particular inequality. We first explain how the inequality implies a performance guarantee (complete details are in [20]), then we show that

our new clean-up step also implies the same inequality. Let F ' denote the edges returned by a call to Uncrossable. The desired inequality

is that at the start of any iteration of Uncrossable, for ~ the family of (currently) ac-

tive sets,

~_~ laF,(C)I <~ 2lcgl - 2. (1) Cc(¢

Williamson et al. prove that the inequality implies that

ZyslaF,(S)I ~ 2 Z y s S S

by induction over all the iterations of Uncrossable. They observe that by construc-

tion of the dual solution, for any e c F ' , ce = ~ s : eta(s) Ys, so that

eEF' ecF r S: eES(S) S S

H.N. Gabow et al. / Mathemat ica l Programming 82 (1998) 13 40

Consider the dual of the linear programming relaxation of (IP):

(D) m a x Zs/ /y.

2 5

SC V ecE

s.t. ~ yS <~ Ce + Ze, e C E, S: eE6(S)

ys ~ O, S C V,

z e r O , e C E .

Given the dual variables y constructed by Uncrossable in phase p, define

ze - ~s: ec~(s)Ys for all e C Fp 1, and ze = 0 otherwise. This gives a feasible solution to (D). Notice that by this definition,

ecE e6Fp i S:eC~(S) S

Since ys > 0 only when h(S) = 1, and h(S) - 1 iff f (S ) ~>p and 16Fp_~(S)] - - p - 1, then

S e S S S

where Z{p is the cost of an optimal solution to (IP). Thus the cost of the edges in F ' is

no more than twice Z~p. Over all f~,~ phases, then, the cost of the generated solution is no more than 2Jm,×Z~p. The exact bound given in Theorem 1.1 is obtained by a slightly more careful analysis.

We now turn to the proof of inequality (1). Our proof strategy is to show that the special edges are exactly those edges whose removal can ensure the inequality. Suppose for a moment, as we did earlier, that no new active sets are created in subsequent iterations. Let e be the edge chosen in the current iteration, and suppose that e is a special edge. Recall that we informally defined a 1-edge e as special if the

edges added to F after e form a tree on the sets active just before e is added. I f e is added in the current iteration and is special, then ~cc~I6F(C)i = 21cgl- 1, but removing e causes inequality (1) to be satisfied (see Fig. 7). This is the central intu- ition of the proof; we employ it recursively in order to handle the more general case.

Theorem 4.1. Given the set of edges F' output by Uncrossable, inequality (1) holds at the start of any iteration.

Proof. Recall the definition of the tree J from Section 2: we create a node of the tree for V and for each set active at some point during the algorithm. A node Vc corresponding to a set C is a child of vD if D is the smallest set of the collection properly containing C. The sets corresponding to the children of vc are denoted ~(C) . We now define the subtree ~--~ of the tree J to contain all the nodes corresponding to sets that will be active in or after the current iteration. Thus the leaves of the tree correspond exactly to the sets in ~ in the current iteration. Define ~(C) to be the sets corresponding to the children of an internal node vc of 3--~; that

26 H.N. Gabow et al. I Mathematical Programming 82 (1998) 13-40

Fig. 7. A bad case for the performance guarantee. Circles represent sets active just before edge e is added. The edge e is special.

is, ? (C) contains the sets of ~ (C) that are active in or after the current iteration. Let Y be the set of edges selected in or after the current iteration. Let Y' = Y N F' .

We will prove inequality (1) by showing for each internal node Vc of the tree Y '

that

( s ~ c ) ' 6 v ( S ) ' ) - '6Y ' (C) ' <<" 2'°~(C)' - 2 (2)

In effect, we prove a version of the inequality for each "equivalence class" C, subtr- acting off the contribution to the total degree made by edges with only one endpoint in C (see Fig. 8). Given that 16y, (V)] - O, by summing this inequality over all internal

nodes Vc of the Y ' , we will obtain

16r,(C)l ,< 2F~ I - 2. (3)

To see this, observe that on the left-hand side, the negative term 16r,(C)l for an internal node Vc is cancelled by the positive term in the inequality of the parent of Vc,

leaving only the positive terms corresponding to the leaves. Similarly, on the right- hand side, the contribution of - 2 for each internal node Vc is cancelled by a contribution of 2 by the parent of Vc, leaving a positive contribution of 2 for each leaf and

=-(,

.~c)

Fig. 8. An illustration of inequality (2). Circles represent sets in C(C). Numbers are the coefficient of the edge in the left-hand side of inequality (2).

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13 40 27

a contribution o f - 2 by the node vv. Inequality (3) implies (1) since @(C) = 8F,(C) for any active set C E ~; that is, no edge o f F ' in the coboundary of an active C could have been added before the current iteration.

Now we must prove inequality (2) on each internal node Vc of the tree. Let

k = Io~(c)l. Let I : Fc N Y, let 45 : ~sce(c) 18/(S)l, and let J be the subset of edges in Y' with one endpoint in V - C and one endpoint in C - Use.e(c) S. Then the inequality on the internal node Vc is implied by

(b - IJI ~< 2k - 2. (4)

The idea behind proving this inequality is that we will always be able to show that ~b ~< 2k - 1, and we will be able to show that • ~< 2k - 2 when ! contains a 2-edge or has more than one "connected component" on the sets g(C). Thus the bad case is exactly when there is a special edge e, no other edges in 1 have been removed, and J = (3, which is precisely when the clean-up step will remove edge e.

In any iteration in which an edge of I is selected, we must make an active set S c •(C) inactive. Thus Ill ~< k. Each edge in I contributes at most 2 to ~, so that we have ~b ~< 2k. I f an edge in I is a 2-edge, then it must make two active sets in g(C) inactive while contributing at most 2 to ~, proving that qb ~< 2k 2, which implies the inequality. Note that if C = V then the final edge in I must be a 2-edge between the final two active sets. There must be two final active sets by the symmetry of hp.

So assume I consists of 1-edges (and thus C ¢ V). Let e be the first edge of I that was selected; i.e., other edges in I were selected in iterations after e was selected. Notice that e can only contribute 1 to ~, since it is a 1-edge. Thus 4~ ~< 2k - 1. Since e is the first edge of /se lec ted , it must be the case that o~/(e) : g(C(e)) by a straight- forward modification of Observation 2.5. I f e is not special, then I contains an edge e' with an endpoint not in any S c g(C). The edge e' contributes 1 to q~, giving q ~ < 2 k - 2.

Now suppose e is special. I f some edge o f / i s deleted in the final edge set F ' , then ~s~e(~e) 16F,.nr'(S)[ <~2k-2, since the edge must have contributed at least 1 to cb = ~sce(~)16/(s)l; note that this implies the desired inequality (2). The remaining possibility is that e is special, was not deleted, and C ¢ V. By the properties of the clean-up step it must be the case that J ¢ (3; hence inequality (4) must hold. []

5. Implementation

In this section, we show how to implement efficiently the various steps of the main algorithm for proper functions. For a general (IP) corresponding to a proper func-

tion f , we obtain a running time of O(JmaxnZm ' + fmaxn2p), where m' = min(f~axn, m) and p is the time taken by an oracle that computes the proper function f . Usually p = O(n) so in practical cases, where f~,x = O(1), the running time is O(n3). For

SNDP we improve the time to O(fmaxnm'+fnaxnx/mloglogn)=O(fZmax n2 +fmaxnx/m log log n).

28 H.N. Gabow et aL / Mathematical Programming 82 (1998) 13 40

Section 5.1 shows how to check if a solution is feasible. The remaining sections discuss the problems of implementation: how to initialize and update the active sets (edge addition step); how to find the next edge to be dded (edge selection step); and how to perform the clean-up step. Notice that in every phase p of the algorithm, Ifl ~< n - 1, whence ]Fpl ~< m'.

5.1. Feasibility

In this section, we show how to check whether a set of edges is a feasible solution to (IP) for a given proper function f . The section introduces some ideas which we use in the following sections on finding and updating the active sets.

We begin by considering the separation problem associated with the constraints x(3(S)) >>, f (S) , where f is proper: given an arbitrary rational vector x, find the most violated inequality x(6(S)) >~ f (S ) or decide that no such inequality is violated. We show that this problem can be solved using the G o m o r y - H u cut tree [9]. Given the

graph G = (V,E) with edge capacities xe, the G o m o r y - H u procedure returns a tree H on the vertices V with values We on its edges such that the value of the minimum cut between any two vertices s and t is given by the smallest value w on the unique path in H between s and t. Let Se and V S,, be the partition of the vertex set induced when e is removed. The tree H also has the property that we = x(6(&,)).

Given a subset S of vertices, let 7(S) denote the edges of H (i.e. of the cut tree) with exactly one endpoint in S (i.e. in the coboundary 6(S)).

Lemma 5.1. Let S C V. Then

x(6(S)) >~ maxw,,. ec~(s)

Proof. We show that for any e = (i,j) • 7(S) we have x(6(S)) >~ w~, = Ix(6(&,))[. This is immediate since, by definition of the cut tree, Se is a minimum cut (or simply mincu t ) separating i and j and therefore has value no greater than the value of any other cut separating i and j. But 6(S) is precisely such a cut. []

Lemma 5.2. Let f be a proper function. Then, for any S c V, we have

f ( s ) ~< maxf(se) . eCy(S)

Proof. Let ( ~ , . . . , Vk) be the vertex sets of the components of the cut tree after removing the vertices in S. By definition, since V - S - V1 U .-. U V~, we have

f (S ) f ( V - S) <~ max(f (Vl) , f (V2) , . . . , f (Vk)) . (5)

Consider any Vi. To simplify notation, assume that S~ is disjoint from V~ for e C 7(Vi) (otherwise, replace & by V X,). Notice that

V - V, = Ue~,,.(~)Se,

tLN. Gabow et al. / Mathematical Programming 82 (1998) 13-40

where the sets appearing in the union are disjoint. Hence,

f ( V - Vii) = f(Vi) ~< maxf(Se) . eC,.(V,)

But, by definition of Vi, we must have 7(Vi) _c 7(S). Therefore,

f(V,) ~< max f(Se). eCy(S)"

Combining (5) and (6), we obtain the desired result. []

29

(6)

From these two lemmas, we can easily derive the following.

Theorem 5.3. maxs{f(S) - x(a(S))} maxecH{f(Se) - x(a(Se))}.

Proof. For any given set S, Lemmas 5.1 and 5.2 imply that

f (S) x(6(S)) <~ maxf(Se) maxx(a(Se)) ~< max(f(Se) -x(cS(&))), eCT(S) eey(S) eC?,(S)

so that

max{f(S) - x(a(S))} ~ m a x { f ( < ) - x(a(&))}.

Obviously the inequality must in fact be an equality. []

This theorem allows us to solve the problem of finding a set S such that f ( S ) - x(a(S)) = m a x r { f ( T ) - x(a(T))} (and hence allows us to solve the separation problem) by solving n - 1 maximum flow problems and restricting attention to the n - 1 cuts defined by the cut tree. In addition, this theorem generalizes a result of Padberg and Rao [16] for T-cuts (cuts S for which IS N T I is odd) or odd cuts (for which ISI is odd). Their result states that the minimum T-cut or odd cut is among the cuts of the Gomory Hu tree. To derive this result from Theorem 5.3, we set

M if ISN T[ odd,

f (S) = 0 otherwise,

where M > x(E), and note that f is a proper function (assuming that Irl is even). Using similar logic, given a {0, 1} proper function, our theorem shows that the minimum cut over all S such that f (S) = 1 is among the cuts of the Gomory Hu tree (using the function Mr). Ravi and Klein [18] independently showed that Padberg and Rao's result could be generalized to proper functions f with range {0, 1 }.

We now describe how to check whether a set of edges generated by the main algorithm is a feasible solution for (IP) with a given proper function. This subroutine was needed in the edge clean-up step of the algorithm of Williamson et al. [20]; they showed how to implement it using O(n 2) max-flow computations. We show how the test can be implemented in O(fm~xnm' + np) time. We do not need this subroutine for our version of Uncrossable; however, some of the concepts here will be useful later. Notice first that the main algorithm selects at most m' edges. Moreover, in the construction of the Gomory -Hu cut tree, we need not solve the maximum flow

30 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13 40

problems to optimality. We can stop as soon as the flow has value f ~ x maxsf(S) , as is justified below. Such a flow can be obtained in O(f~×m') time by locating up to fma~ augmenting paths. For small values Offmax, we can construct the G o m o r y - H u cut tree without using a maximum flow subroutine. For example, the case f~ax = 1 reduces to finding connected components while the case fmax = 2 reduces to computing the 2-edge-connected components of a graph (which can be done in linear time).

To avoid computing maximum flows to optimality, we modify the procedure for constructing the cut tree, since whenever the maximum flow has value greater or equal to fmax we cannot use information from a mincut. First recall the classical procedure of Gomory and Hu [9]. The procedure starts from one supervertex containing all vertices of the graph. At any stage of the construction, there is a partial tree whose (super)vertices form a partition of the vertex set. The procedure selects two vertices u and v within a supervertex A, shrinks the vertices in each connected component resulting from the removal of A from the cut tree, and computes the maximum flow and minimum cut between u and v in the resulting shrunk graph. The supervertex A is split into two supervertices linked by an edge, in such a way that the removal of this edge induces the computed mincut. The new edge of the cut tree gets labeled with the value of the maximum flow between u and v. The algorithm terminates when each supervertex consists of a single vertex of the graph, and its output is the tree with the labels produced.

Our modified procedure is similar to the classical procedure, but it also maintains a forest for each supervertex of the cut tree. The forest for a supervertex is defined on the vertices contained in the supervertex. In the modified procedure, we select two vertices, say u and v, of two different components of a forest of the same supervertex, say A. We compute the maximum flow (up to the value fm~x) between u and v in the shrunk graph, as in the classical procedure. If the maximum flow value is at least fma~, we add the edge (u, v) to the forest of the supervertex A and label the edge " ~> Jmax". Otherwise, we split A (and its forest) as in the classical algorithm; by submodulari ty and the definition Offmax, one can easily show that each connected component of the forest defined on A will end up entirely within one of the two new supervertices. The modified algorithm terminates when each supervertex is either a single vertex or the forest for the supervertex is a tree on its vertices. We replace every supervertex by its associated tree and output the resulting tree as the modified G o m o r y - H u subtree.

By the same argument as in [9], for any vertices s and t, the value of a maximum flow from s to t and a corresponding mincut can be obtained from the modified cut tree, provided that this maximum flow value is at most f~ax 1. We should also point out that Lemma 5.1 is still valid for this modified cut tree. Thus, for the incidence vector of a graph with at most m' edges, the modified cut tree can be constructed in O(fmaxnm') time, since we solve n flow problems by finding up to fmax augmenting paths in a graph of m' edges. The separation problem can be solved in O(fma~nm' + np) time by constructing the modified cut tree and examining each edge.

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13 40 31

5.2. Active sets

This section shows how to find and update the active sets for calls to Uncrossable generated by our main algorithm. When sets are violated, the G o m o r y - H u cut tree does not immediately give the minimal violated sets. However, we can use the lemma below. Let F be the set of edges selected so far by Uncrossable. Let H be the Go- m o r ~ H u cut tree corresponding to the graph with edge set Fp_l. Recall that set S is violated in the call to Uncrossable in phase p of the main algorithm if

136, ~ur(S)] = p - 1 and f ( S ) >~ p.

Lemma 5.4. Any violated set at any point in the call to Uncrossable in phase p is an (s, t) mincut for some edge e - (s, t) C H satisfying We = p 1.

Proof. Let S be any violated set at any point in the call to Uncrossable in phase p; i.e.,

f ( S ) >~p and I6F~_luF(S)I = p - - 1. Since we know 16F,, 1(S)1 ~> min( f (S) ,p 1), it must be the case that IC~F,~, (S)l = p - 1. From Lemma 5.2, there must exist an edge e = (s, t) in y(S) with f (Se) >1 p. Since 16Fp_l (Se)l >~ m i n ( f ( S e ) , p - 1), we must have that We= 16F~ l(Se)l ~ > P - 1 . Since 16Fp 1(S)1 = p - l , Lemma 5.1 implies that We = p -- 1. Hence, S defines a cut of minimum value between s and t. []

When we initially call Uncrossable in phase p, we form the G o m o r y - H u cut tree corresponding to the graph with the edge set Fp_l. Because of the lemma above, in the call to Uncrossable in phase p we shall keep track of all (s, t) mincuts for each edge e = (s, t) c H with We = p -- 1. We use the compact representation of all (s, t) mincuts due to Picard and Queyranne [17]. Given a maximum flow from s to t for an edge e = (s, t) E H, form a directed acyclic graph G~ from the residual graph of the flow by contracting each strongly connected component, as well as the set of all vertices reachable from s, and the set of all vertices that can reach t. For notation- al simplicity, let S and T denote the supervertices of Ge containing s and t, respectively. Picard and Queyranne observe that there is a 1-1 correspondence between the (s, t) mincuts and the (T, S) dicuts of Ge, where a (T, S) dicut is a cut with all arcs directed from the side of the cut containing T to the side containing S. Given a maximum flow, digraph Ge can be computed in O(m') time since the residual graph contains O(m') edges. As Uncrossable adds edges to F, we will update the graphs Ge so that the (T, S) dicuts reflect the minimum (s, t) cuts of value p - 1 in Fp 1 U F; we will explain how to do this later in the section.

Consider a topological ordering of Ge (i.e., a numbering of the supervertices so that any edge of Ge goes from a lower-numbered supervertex to a higher-numbered supervertex). Because we contracted into the supervertex T all vertices in the residual graph that can reach t, the first supervertex in the ordering can be assumed to be T. Similarly, since all vertices reachable from s have been contracted, we can assume that S is the last supervertex in the ordering. By definition, all the supervertices that. are predecessors of some supervertex A in the ordering must induce a (T, S) dicut and

32 H.NI Gabow et al. / Mathematical Programming 82 (1998) 13~40

hence an (s, t) mincut but, clearly, not all (s, t) mincuts arise in this fashion. Never- theless, we will show that we can limit our attention to particular (s, t) mincuts aris- ing in this way.

Lemma 5.5. Let e = (s, t) be an edge in the Gomory Hu tree H such that we -- p - 1.

A t any point o f Uncrossable in phase p, there exists a violated set separating t f rom s i f

and only i f there exists a supervertex A o f Ge with f ( A ) >~ p.

Proof. Only i f part. Any violated set S must be the union of supervertices Ai. By the maximality property of proper functions, at least one of the supervertices must satisfy f ( A ) >>, p.

I f part. Choose the first supervertex A in the ordering such that f ( A ) >~ p. Consid- er the union C of all the predecessors of A in Ge. This set C induces an (s, t) mincut. Moreover, C - A consists of the union of supervertices A'is with f (A i ) < p, so that by

maximality, f ( C - A) < p. By symmetry, f ( V - A) - f ( A ) >~ p. By maximality, f ( V - A ) < ~ m a x ( f ( C A ) , f ( V - C ) ) , which implies that f ( V C)>~p. Thus f ( C ) >>, p; C is a violated set at the beginning of the call to Uncrossable since f ( C ) >~p and C is an (s,t) mincut, implying 166, ,uF(C)] = p -- 1. []

Theorem 5.6. Let e be an edge in the Gornory-Hu tree H such that We = p -- 1. Let A be

the f irst vertex in the topological ordering o,1" Ge such that f ( A ) >~ p, and let C be A together with its predecessors in Ge. IJ" there exists an active set separating t ji"orn s at

any point o f Uncrossable in phase p, it must be C.

Proof. Suppose there is an active set C t containing t but not s. By Corollary 2.2, an active set cannot cross a violated set and, hence, U c_ C. Since U is a violated set, it must be the union of supervertices of Ge. Moreover, it must contain A since

f ( U ) >~ p and A is the only supervertex within C which has a value at least p. Furthermore, since C ~ corresponds to an (S,T)-dicut of Ge, it contains all predecessors of A in Ge. Thus C ~ = C. []

This lemma motivates the following procedure in order to find a potentially active set C containing t but not s. Scan the supervertices A of Ge in the topological order, calling the oracle for each supervertex A and stopping as soon as f ( A ) >~ p. Set C to be A together with its predecessors in Ge.

In a similar manner, we can also find a potentially active set containing s but not t. These two sets can be constructed in O(m' + np) time per graph Ge. By doing this for all edges e E H with We = p -- 1, one thus constructs in O(nm' + n2p) time a family of O(n) violated sets guaranteed to contain all active sets; this follows from Lemma 5.4. The active sets can be obtained from this family in O(n 2) time by finding the minimal

sets in this family. This can be done by keeping track, for each vertex, of the set (if unique) of smallest cardinality containing it.


In summary, the modified cut tree for Fp_l and the initial active sets of Uncross-

able in phase p can be obtained in O(fm~xnm' + n2p) time: O(Jma×nm') time to construct the modified G o m o r y - H u tree, O(nm') time to construct all the possible Ge, and O(nm' + nZp) to extract the active sets from the Ge.

When the addition step adds edge e' to F the active sets must be updated. How- ever, the sets that are active once e' is added are sets that were violated at the beginning of a call to Uncrossable in phase p. We can therefore use exactly the same procedure as above to recompute the active sets. More precisely, we update the O(n) G~ by adding the (bidirected) edge e' to them and recomputing their strongly connected components in O(m') time per Ge. Then we create a family of O(n) potentially active sets and extract from this family the minimal sets. In this case though, we can just make one oracle call (instead of O(n)) per Ge since, by adding an edge to a digraph, only one new strongly connected component can be created. Recomputing the active sets for each edge added therefore takes O(nm' + np) time. Using our assumption that fmax ~< n, the time to find the active sets in all iterations of a phase is thus O(nZm' + nZp) . Over all phases, this becomes O(JmaxnZml + f~xn2p).

5.3. Active sets for SNDP

This section refines the implementation of the edge addition step given in Sec- tion 5.2 for SNDP. It achieves total time O(nm') for the addition steps of one phase,

and thus O(fm~xnm') over all phases. For SNDP, we do not need to construct the G o m o r ~ H u cut tree to test feasibil-

ity. We use a maximum spanning tree T of the graph having cost rij on edge (i,j). Any set satisfying the connectivity requirements of the edges of T satisfies all given requirements rij [9]. It is easy to see that the violated sets of phase p must correspond to mincuts of value p 1 associated with an edge e = (s,t) of T having

f(S~) = r~t >~ p. However, in this case, we have a 1-1 mapping: any such mincut must correspond to a violated set. As a result, any active set must be a minimal (s, t) mincut or a minimal (t, s) mincut for some (s, t) E T.

We maintain these minimal mincuts over the entire algorithm. To do this we maintain, for each edge (s, t) in T, an s t flow with value no larger than rst. At the beginning of phase p, we start from the flows that were computed in phase p - 1 and find augmenting paths for each edge e in T up to value p, if possible. Thus in phase p we can detect any edge (s, t) of T for which the cut value is p - 1 while rst ~> p. Over the course of the algorithm we must find at most fm~x augmenting paths for the flow for each edge of T, leading to a total time bound of O(fm~xm'n) for maintaining these flows.

Suppose for an edge e - (s, t) in T, the cut value is p - 1 while r~t ~> p. Initially, the minimal (s, t) mincut consists of all vertices reachable from s in the residual graph of a maximum flow from s to t. The minimal (t, s) mincut is similar. As before, we can extract the active sets from these mincuts in O(n 2) time. Whenever an iteration adds an edge e = (u, v) to the edge set F, each minimal mincut is updated. For example for the minimal (s, t) mincut, if u is reachable f rom s then so is v, as is any vertex

34 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~40

reachable from v by residual edges. If t becomes reachable then we disregard edge (s, t) in the tree T for the rest of the phase. The total time in phase p to update the minimal (s, t) mincut amounts to a search of the residual graph, and thus uses time O(m'). Thus the total time in a phase for updating all edges (s, t) of T is O(nm'). To find the new active set (if any) resulting from the addition of edge (u, v), we search through the O(n) candidate sets for the smallest violated set containing u. The smallest such set will be a new active set if it contains no other currently active sets. The search for the set takes O(n) time. Therefore, the total time for the edge addition step in a phase p is O(nm') for SNDP, leading to a total time bound of O(Jmaxnm') over the course of the whole algorithm.

5.4. Edge selection step

This section shows how to implement the edge selection step of Uncrossable in time O(n(n + ~/m log log n)). It uses a lemma allowing irrelevant edges to be ig- nored, plus the data structure idea of packets due to Gabow et al. [4].

Say that "t ime" is zero at the beginning of Uncrossable, and time increases by the amount c determined in each iteration (see Fig. 2). As in [8] our implementation keeps track of the addition time at which an edge would be selected ~'the set of active sets cop were not to change. The addition time of an edge (u, v) in the coboundary of b active sets at time t is formally defined as t(u, v) t + [c,~,- d(u) - d ( v ) l / b . Here d(u) and d(v) denote their values at time t, b = 0, 1 or 2; the addition time is oc if b = 0. The addition time does not change unless the active set containing u or v changes. It is easy to see that at time t the edge selection step adds an edge with the smallest addition time (at time t) to F.

We maintain a partition of V into a-sets. At any time in phase p the a-sets are defined as follows: Contract each currently active or previously active set to supervertices. We now have as vertices these supervertices plus the vertices which have never been in any active set. An a-set corresponds to a tree in the forest induced by edges F on these vertices. Note, then, that each vertex which has never been in any active set and is not incident to an edge of F is a singleton a-set (it corresponds to an empty tree). Note also that at any time any currently active set is an a-set. An a-set that is not a singleton or currently active set is a maximal collection of maximal previously active sets joined by edges o fF , plus possibly a singleton set. We give an example of the a-sets from frame 4 of Fig. 5 in Fig. 9.

Notice that among edges joining the same two a-sets, we can discard all but the one with smallest addition time; the other edges will always have addition time no smaller than this smallest edge. Let I C E denote the subgraph of G consisting of these edges. Assume that in choosing the next edge to add, the selection step breaks ties for smallest addition time according to some fixed numbering of the edges. Thus any set of edges is totally ordered by addition time; in particular its kth smallest edge is unique. Throughout this section, we compare edges using addition time, not cost, e.g., "kth smallest edge" refers to addition time.


. . . . . . . . s

I '+ + ~ I t+, , , I I I I

i - - + ~ i I I I ,o', , ,

; e ' , ',_o., I I I I I I I I , ® : ,_e, : e ,

Fig. 9. Example of a-sets from frame 4 of Fig. 5 (a-sets are contained in dashed lines; solid lines show previously active sets).

Let A(u) denote the a-set containing ut and let a denote the current number of a- sets. Our algorithm is based on the following principle.

Lemma 5.7. Fix an iteration in the while loop of Uncrossable. Consider an edge (u, v) c 6i(A(u)) that is not among the 2k smallest edges of 6i(A(u)). Then (u, v) is not added to F until A (u) has changed or A (v) has changed or a has decreased by k.

Proof. Suppose (u, v) is added to F in an iteration when neither A(u) nor A(v) has changed. Consider an edge (u I, v'), one of the 2k smallest edges of 6](A(u)). When (u, v) is added to F, (u', v') has not been added (since A(u) has not changed). Thus the addition time of (u', v') has increased, implying that A(v') has changed. Thus the 2k distinct sets A(v') have changed. These 2k changes must be the result of merging various a-sets which include the 2k sets A(vl). Thus a must have decreased by at least

k. D.

The lemma above will allow us to ignore particular sets of edges during some portions of the while loop of Uncrossable. In order to take advantage of the lemma, we partition the main loop into subphases. Let r be a parameter to be chosen later. Each time a has decreased by r or more since the start of the current subphase, a new subphase will begin. We will designate certain edges to be awake in such a way that Lemma 5.7 will imply that an edge (u, v) that is not awake in this subphase need not be considered unless A(u) or A(v) changes. At the beginning of a subphase, we choose the 2r smallest edges in the coboundary of every a-set. Any edge chosen by the a-sets of both its endpoints will be initially designated an awake edge.

In order to keep track of the awake edges, we use a number of priority queues. A priority queue entry is an edge that is awake and joins two distinct a-sets. Its priority is equal to its current addition time. The awake edges incident to each a-set are par- titioned into packets of no more than log n edges each. One distinguished packet is called the growing packet; the other packets are ordinary packets. Each packet is a priority queue. Every awake edge joining two distinct a-sets is in precisely two

36 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~I0

packets, corresponding to its two ends. In addition to the packets, we also maintain a priority queue D. An edge is a double minimum if it is awake and is the minimum of both its packets, and these packets are ordinary. The queue D contains all such double minima. Our description implies that the edge with the smallest addition time is the minimum edge of D or the minimum edge of a growing packet.

Given these data structures, the edge addition step will work as follows. To start a subphase, each a-set chooses the 2r smallest edges in its coboundary. An edge that is chosen by both its ends is awake. The awake edges are organized into packets. Any edge that is a double minimum is placed in D. To select the next edge e for F, choose the smallest edge among the minima of D and all growing packets. Let A be the new a-set created by adding e to F. Delete all edges incident to vertices of A from their packets and from D. If this causes a new packet minimum to be a double minimum, add it to D. Note that now all packets corresponding to A are empty, so initialize a new growing packet. We now need to choose the awake edges incident to A. To do this, examine all edges incident to A, awake or not. Discard any parallel edges between A and other a-sets, always keeping the smallest. The 2r smallest undiscarded edges incident to A will be designated awake edges. Add each such edge (u, v) to the two growing packets of A(u) and A(v) (one of these is A). Whenever a growing packet gets log n edges, make it an ordinary packet and start a new growing packet; also possibly add an entry to D for a new double minimum. The algorithm is correct because it maintains the defining properties of the packets and D. Lemma 5.7 justifies ignoring the edges that are not awake.

Before we estimate the running time, we observe that in any subphase, for any a- set A, at most 3r edges of 6(A) become awake. To see this, notice at most 2r such edges are awake when any a-set A is initialized. After initialization, each iteration can make at most one more edge of 6(A) awake. Thus at most r more edges are made awake before the subphase ends. As a result, any a-set A has at most 3r/log n packets at any point in a subphase.

First we bound the time for deletions and insertions from the priority queues. By the observation above, an iteration that decreases the number a of a-sets by j deletes at most O(jr) edges from packets and at most O(jr/logn) edges from D. Thus all addition steps delete a total of O(nr) edges from packets and O(nr/log n) edges from D, for a total time of O(nr log log n + nr) for all deletions (since packets have at most log n edges and D has at most n edges). To bound the time on the insertions, note that at most O(nr) edges ever enter packets and at most O(nr/log n) edges ever enter D. Since these bounds are no larger than the total number of edge deletions, the total time for edge insertions must also be O(nrlog log n).

Putting everything together, note that there are at most n/r subphases. Using linear-time selection, we can construct packets and D in O(m) additional time at the start of each subphase. We need O(n) amortized time whenever an edge is selected for dis- carding parallel edges, examining the edges incident to A, and updating A(u) values. Thus the total time is O(n 2 q- nm/r + nr log log n). Choosing r - ~/m/log log n gives total time O(n(n + ~/m log log n)) for the edge selection step.

H.N. Gabow et al. / Mathematical Programming 82 (1998) 13-40

5.5. L#war time clean-up step

37

This section shows how to implement the clean-up step in time O(n). The imple-

mentation is based on a tree ¢- and auxiliary arborescences Zc which we now define.

The tree Y is a modification of the tree ~- used to represent the active sets over the course of the algorithm, as defined in Section 2. Recall that .Y- is constructed by

creating a node Vc for each C E U~g, where U~ is the collection of all active sets over

all iterations, plus the set V. The node VD is a parent o f v c in oY- i fD is the smallest set in UCg that properly contains C. To form Y, we create one additional child node for

each internal node Vc of the tree to represent the set of vertices in C that are not in the other children of Vc.

For each node Vc in Y, we construct an arborescence zc. Recall that a branching

is a directed forest in which every node has in-degree at most 1, and an arborescence

is a connected branching. Using the edges of Fc, we form a branching /~c on the nodes corresponding to the children of C in J . An edge (VA, V~) is created for each

edge e EFc when edge e is in the coboundary of the sets A and B. Each 2-edge is di-

rected arbitrarily, while a 1-edge is directed towards the active set that defines it. The

edges of Fc form a branching since two edges of F cannot be directed towards the

same active set. It can be converted into an arborescence rc by adding a node con-

nected to all the roots of the branching. Both the tree Y and the arborescences rc

can be easily constructed during the edge addition stage of Uncrossable and the run-

ning time for their constructions can be charged to this stage. In Fig. 10, we give an example of ~c for C -- C(el) from Fig. 5.

Before we explain the clean-up procedure, we make the following observation.

Observation 5.8. A 1-edge e in Fc (for C = C(e) ) is special i f and only i f all the edges o f

Fc added to Zc after e f o rm an arborescence with the head o f e as its root.

Proof. This follows since a 1-edge e is special if and only if all the edges of Fc added

after e form a spanning tree on the active sets corresponding to children of Vc. Such a

[es i

a o

e 5

Fig. 10. Example of arborescence ~c for C C(el ) from Fig. 5. The left-hand side shows edges on under- lying vertices, while the right-hand side shows the arborescence.

38 H.N. Gabow et al. / Mathematical Programming 82 (1998) 13~40

spanning tree will necessarily cause rc to be an arborescence directed away from the head of e since whenever a 1-edge is directed into a node corresponding to an active set, all edges added after it must be directed away from the node. []

We find all special edges in O(n) time as follows. We consider each active set C E Ucg in turn. Suppose Fc consists of el, • • •, et, where ei was added before ej for i < j. Let li denote the least common ancestor of the heads of e~, . . . , et in ~c. By the reasoning above, a 1-edge ei is special if and only if li is the head of edge e~ in rc. The li's can be found in linear time by processing the edges in reverse order, by marking the nodes along the path to the ancestor and by stopping at the first previously marked node.

We would like to implement the edge clean-up step by performing a top-down traversal of J . Let F" be the set of edges remaining after a clean-up step that works as follows: we perform a top down traversal of Y-. At each node Vc of ,Y-, we process the edges of Fc in the reverse order in which they appear in F, detecting and possibly removing a special edge e of Fc under the same condition as before (i.e., no other edge of Fc has been removed and all remaining edges of F in (3(C(e)) are also in 6(A(e))). We begin by proving the following lemma.

Lemma 5.9. F" F'.

Proof. Observe that the removal of an edge e of Fc depends only on the edges in Fc and 6F(C), and affects only the removal of edges in Fc and in FD, for nodes D with e C 6(D). Such a set D must be a descendant of node vc in the tree J , and any node

VA such that edges of 6F(C) are in FA must be an ancestor of C. By Observation 2.4, all edges of Fc occur in F before any edge in ~3(C) and after any edge in Fz), for VD a descendant of vc. Thus the set of edges F" formed by removing edges in a top down traversal of J will be the same as that in U . []

When visiting a node Vc in ,Y-, we need to decide which special edge of Fc to remove, if any. Call a child vB of Vc hit if there exists an edge already processed but not removed that is simultaneously in the coboundaries o r b and C. We show below that we can use information about hit children of vc to determine which special edge of Fc to remove, if any.

M

Lemma 5.10. A special edge e of Fc is removed in the top down traversal of J if and only i f it is the deepest special edge e in Tc whose head is an ancestor in rc of all the hit children of vc.

Proof. Recall that while considering the edges of Fc in the reverse of the order added, we remove special edge e of Fc if and only if no other special edge has been deleted and all remaining edges in 6(C) are also in 6(A(e)), where A(e) is the union of sets in ~ ( e ) . By the discussion above, for any special edge e in Fc, the sets in sC~(e) correspond


exactly to the descendants of the head of edge e in zc. Thus all remaining edges in 6(C) are also in 6 (A (e)) for special edge e if and only if the head of e is an ancestor in zc of all the hit children of vc. Finally, by the discussion above, because any edges in Fc added after a special edge e must be edges in zc between descendants of the head of e, the depth of the special edges in zc is strictly increasing with respect to the order in which the special edges were selected. Hence the deepest special edge e in zc

whose head is an ancestor in Zc of all the hit children of vc (if any such edge exists) is exactly the edge which will be removed. []

Our procedure will be as follows. For the moment, we assume that when we visit a node Vc, the hit children of vc have been correctly marked. Under this assumption, the lemma above tells us that we can detect the appropriate special edge to remove while determining the special edges of Fc. Once we have decided which special edge of Fc to remove (if any) and which edges to keep, for each edge e (u, v) E F c that we keep, we mark the nodes of the paths in ~- from the leaves u and v up to (but excluding) their common ancestor Vc as hit nodes. Notice that this may incorrectly mark children of vc as hit nodes, but this no longer matters since we have already processed the edges of Fc. In order for this marking procedure to run in linear time, we stop marking a path before reaching Vc if we encounter an already hit node. The validity of this stopping rule follows from the fact that we perform a top down traversal of 3-, since if node vD on a path to Vc is marked, so are all ancestors of vD up to Vc. The top-down traversal also ensures that when we reach a node vD, all of its hit children are correctly marked. Therefore, the overall running time of the clean-up step is O(n) time.

6. Concluding remarks

Since the appearance of a preliminary version of this paper [5], Goemans et al. [6] have shown how the performance guarantee of the algorithm can be improved from

1 Their algorithm uses an algorithm 2Jmax to Z~4~(f~ax), where 24"(k) = 1 + ½ + . . . + ~. for uncrossable functions as a black box, so our version of Uncrossable can still be used. Furthermore, they show that their algorithm can be implemented by making small modifications to our implementations, yielding a 2~(fmax)-approximation algorithm with the same running times as our algorithm above. This entire line of research has been summarized in the thesis of Williamson [19].

Acknowledgements

We are grateful to an anonymous referee for many useful comments. The first author pays tribute to Gene Lawler, who provided help and inspiration for many


years. The third author thanks David Johnson and AT&T for inviting him to spend the summer of 1992 at Bell Labs.

References

[1] A. Agrawal, P. Klein, R. Ravi, When trees collide: An approximation algorithm for the generalized Steiner problem on networks, SIAM Journal on Computing 24 (1995) 440M56.

[2] P. Berman, V. Ramaiyer, Improved approximations for the Steiner tree problem. Journal of Algorithms 17 (1994) 381-408

[3] G.N. Frederickson, J. Ja'Ja', Approximation algorithms for several graph augmentation problems, SIAM Journal on Computing 10 (1981) 27~283.

[4] H. N Gabow, Z. Galil, T.H. Spencer, R.E. Tarjan, Efficient algorithms for finding minimum spanning trees in undirected and directed graphs, Combinatorica 6 (1986) 109-122.

[5] H.N. Gabow, M.X. Goemans, D.P. Williamson, An efficient approximation algorithm for the survivable networks design problems, in: Proceedings of the Third MPS Conference on Integer Programming and Combinatorial Optimization, 1993, pp. 57-74.

[6] M. Goemans, A. Goldberg, S. Plotkin, D. Shmoys, E. Tardos, D. Williamson, Improved approximation algorithms for network design problems, in: Proceedings of the Fifth Annual ACM-SIAM Symposium on Discrete Algorithms, 1994, pp. 223 232.

[7] M.X. Goemans, D.J. Bertsimas, Survivable networks, linear programming relaxation and the parsimonious property, Mathematical Programming 60 (1993) 145-166.

[8] M.X. Goemans, D.P. Williamson, A general approximation technique for constrained forest problems, SIAM Journal on Computing 24 (1995) 296--317.

[9] R. Gomory, T. Hu, Multi-terminal network flows, SIAM Journal of Applied Mathematics 9 (1961) 551-570.

[10] M. Gr6tschel, C.L. Monma, M. Stoer, Design of survivable networks, in: Network Models (Handbooks in Operations Research and Management Science, vol.7), M.O. Bell, T.L. Magnant, C.L. Monma, G.L. Nemhauser, eds, North-Holland, 1995.

[11] D. Gusfield, D. Naor, Extracting maximal information about sets of minimmn cuts, Algorithmica 10 (1993) 64-89.

[12] S. Khuller, U. Vishkin, Biconnectivity approximations and graph carvings, Journal of the ACM 41 (1994) 214-235.

[13] P. Klein, R. Ravi, When cycles collapse: A general approximation technique for constrained two- connectivity problems, in: Proceedings of the Third MPS Conference on Integer Programming and Combinatorial Optimization, 1993, pp. 39-55 (also appears as Brown University Technical Report CS-92-30, to appear in Algorithmica).

[14] P.N. Klein, A data structure for bicategories, with application to speeding ap an approximation algorithm, Information Processing Letters 52 (1994) 303 307.

[15] K. Mehlhorn, A faster approximation algorithm for the Steiner problem in graphs, Information Processing Letters 27 (1988) 125-128.

[16] M.W. Padberg, M. Rao, Odd minimum cut-sets and b-matchings, Mathematics of Operations Research 7 (1982) 67 80,

[17] J. Picard, M. Queyranne, On the structure of all minimum cuts in a network and applications, Mathematical Programming Study 13 (1980) 8 16.

[18] R. Ravi, P. Klein, Approximation through uncrossing, unpublished manuscript. [19] D.P. Williamson, On the design of approximation algorithms for a class of graph problems, Ph.D.

Thesis, MIT, Cambridge, MA, 1993 (also appears as Tech. Report MIT/LCS/TR-584). [20] D.P. Williamson, M.X. Goemans, M. Mihail, V.V. Vazirani, A primal-dual approximation algorithm

for generalized Steiner network problems, Combinatorica 15 (1995) 435-454. [21] A. Zelikovsky, An 1 l/6-approximation algorithm for the network Steiner problem, Algorithmica 9

(1993) 463-470.

Documents

An efficient approximation algorithm for the survivable ...math.mit.edu/~goemans/PAPERS/GabowGoemansWilliamson-1998-… · An efficient approximation algorithm for the survivable