Massaging a Linear Programming Solution to Give a 2-Approximation ...

Massaging a Linear Programming Solution to Give a 2-Approximation For a Generalization of the Vertex Cover Problem Nader H. Bshouty

Lynn Burroughs

Department of Computer Science The University of Calgary Calgary, Alberta, Canada T2N 1N4

e-mail: fbshouty,[email protected]

Abstract

Linear programming relaxations of integer programs have been used extensively in designing approximation algorithms for optimization problems. For vertex cover, the linear programming solution can be directly interpreted to give a 2-approximate solution, rivaling the best known performance ratio. This is achieved by forming a cover from the vertices that exceed a threshold of 12 in the linear programming solution. For a generalization of vertex cover we call vct , in which we seek to cover t edges, the linear programming solution does not immediately give a good solution. In fact, the approach used for vertex cover may not yield a feasible solution at all. We introduce a new technique for massaging a linear programming solution to get a good, feasible solution for this problem. We alternate between manipulating the values of the linear programming solution and collecting vertices that exceed a threshold of 21 . We will prove that this method achieves a performance ratio of 2 for vct with unit weights. We then give a second algorithm that extends the result, giving a 2-approximation for vct with arbitrary weights. We show that this is tight in the sense that any -approximation algorithm for vct with  < 2 implies a breakthrough -approximation algorithm for vertex cover.

1 Introduction Linear programming relaxations of integer programs have been used extensively in designing approximation algorithms for optimization problems [Ho82] [RT87] [GW94b]. A similar idea, relaxing integer programs to semide nite programs, has recently brought exciting advancements in the approximability of several problems including maximum cut [GW94a] and k-colourable graph colouring [KMS94], although attempts to use semide nite programming for vertex cover [KG95] have not provided improvements over existing algorithms.  This

research was supported in part by the NSERC of Canada.

Given an integer program description of a problem, we relax some of the constraints to get a linear program. The linear program can be solved in polynomial time using the Ellipsoid method [Kh79] or one of many interior point methods, the rst of which was described in [Ka84]. The rational solution to the linear program is then interpreted to get an integer approximate solution to the original problem. vertex cover is one natural application for this tool. The vertex cover problem is, given a graph G = (V; E ) and a weight function ! : V ! Z , nd a set C  V such that all edges in E have at least one endpoint in C and the total weight of the vertices in C is minimized. Numerous approximation algorithms for vertex cover in general graphs exist, including [BE85]. The best of these achieve a performance ratio of 2. Johan Hastad has proved in [Ha97] that a performance ratio less than is not possible unless P = NP. One straightforward approximation algorithm for vertex cover using linear programming and a thresholding technique is due to Hochbaum [Ho82]. Given an instance G = (V; E ), the linear program is solved to get a value xi 2 [0; 1] for each vi 2 V , and the cover is given by C = fvi j xi  g. It can be shown that C is a vertex cover and has size at most twice the optimal size. Thus the algorithm is a 2-approximation algorithm for vertex cover. For some applications of vertex cover, it may be sucient to nd a set C  V such that t edges in E have at least one endpoint in C . Here t is a xed integer function of jV j or jE j, i.e., t : N ! N . We call the set C a t-cover of G. This generalization of vertex cover will be called vct . We will show that for many functions t, vct has an approximation-preserving reduction to vertex cover and thus an -approximation algorithm for vct implies an approximation algorithm for vertex cover. Therefore it would be dicult to nd better than a 2-approximation and highly unlikely that we would nd better than a -approximation for vct in general graphs. One might think that an optimal t-cover for G is simply a subset of an optimal vertex cover in G. But for many graphs this is not the case. In fact, a feasible t-cover formed from an optimal vertex cover may be arbitrarily larger in size than the optimal t-cover. Unfortunately the simple algorithm given for vertex cover above does not work for vct. In fact, the set fvi j xi  g may not be a feasible solution to vct . We need a dierent approach. We present a new technique for massaging the LP solution to prepare it for thresholding. This technique guarantees a 2-approximate solution for vct for any function t. B ? )-approximation for vct We present our technique in two algorithms. The rst gives a (2+ OP T where B is the largest nite weight in the problem de nition and OPT is the optimal value for the instance. The second algorithm uses the rst as a subroutine and achieves an approximation ratio of 2. Our rst algorithm goes through three phases in creating a t-cover using the LP solution. The rst phase takes vertices that exceed a threshold of in the LP solution. In the second phase we work with the subgraph induced on the remaining vertices and interpret the remainder of the LP solution as values on the vertices and edges. We massage these values, performing a series of adjustments wherein a fraction of the value of one vertex is shifted to another vertex. While performing these adjustments, we keep the value of the objective function the same, keep the total edge value from decreasing and maintain a certain relationship between the edge and vertex values. Our aim is to concentrate the values of several vertices into a single vertex. Once +

7 6

1 2

7 6

1 2

1

1 2

2

a vertex assumes a value of , we put that vertex in the cover and remove it from the subgraph. When no more adjustments can be made, we show that at most one vertex is left and we may choose to include it in the cover. We show that this algorithm runs in polynomial time, covers B ? times the optimal number of vertices. Thus it is a at least t edges and uses at most 2 + OP T 2-approximation algorithm for vct with unit weights. The second algorithm improves the bound for vct with arbitrary weights to 2 by searching for the largest vertex weight in an optimal cover. While the use of linear programming relaxations is not new, previous uses of this tool involve direct thresholding as in [Ho82] or a randomized rounding technique as in [RT87] and [GW94b]. Our technique follows the thresholding approach, but is not restricted to using the raw linear program solution. Instead we massage the linear programming solution to prepare it for the thresholding technique. This allows for a higher threshold and thus a better approximation than is possible from using the raw values. 1 2

1

2 Preliminaries

We will assume that an instance of vct is a graph G = (V; E ) and a weight function ! : V ! f1; 2; : : : ; B; 1g with V = fv ; : : : ; vng. The value of the optimal t-cover for G (i.e., the total weight of the vertices it contains) will be denoted OPT (G; !; t) or may be abbrieviated to OPT if the instance is P clear from the context. For an arbitrary set of vertices C we will use the notation !(C ) to mean v2C !(v). To express an instance G = (V; E ) of vct as an integer or linear program, we assign a variable xi to each vertex vi 2 V and a variable yij to each edge (vi; vj ) 2 E . The integer program is as follows. 1

OPT (G; !; t) = Min Subject to

n X

!(vi)xi

X

i=1

v ;vj )2E

yij  t

( i

xi + xj  yij 8(vi ; vj ) 2 E xi 2 f0; 1g i = 1; : : : ; n xi = 0 8vi with !(vi) = 1 yij 2 f0; 1g 8(vi ; vj ) 2 E We de ne the product of zero and 1 in the objective function to be zero. If the program is infeasible we will de ne OPT (G; !; t) = 1. For feasible programs, an optimal t-cover is given by C = fvi j xi = 1g. The edges covered are f(vi; vj ) 2 E j yij = 1g. Unfortunately there is no known polynomial-time algorithm to solve the integer program for arbitrary t. We relax the constraints of the integer program to get the linear program below.

3

(P 1)

n X

LB (G; !; t) = Min

!(vi)xi

X

i=1

Subject to

v ;vj )2E

yij  t

( i

xi + xj  yij 8(vi; vj ) 2 E xi  0 i = 1; : : : ; n xi = 0 8vi with !(vi) = 1 0  yij  1 8(vi; vj ) 2 E The relaxation can be solved in polynomial time using the Ellipsoid method or an interior point method. Furthermore, since the constraints of the integer program are a subset of the constraints of the linear program, LB (G; !; t)  OPT (G; !; t). We will assume without loss of generality that for each edge (vi ; vj ), yij = min(xi + xj ; 1). If yij < min(xi + xj ; 1) then we may increase yij until equality holds. This increase neither violates the constraints of the program, nor does it aect the value of the objective function. To see why the simple linear programming algorithm for vertex cover does not work for vct , let t = jE j and consider the instance K 4 (the complete graph on four vertices) with all weights equal to 1. The optimal solution clearly requires 2 vertices to cover 4 edges. One optimal solution to the linear program is given by x = x = x = x = , and yij = xi + xj = . Using a threshold of which was sucient for vertex cover, we form C = fvi j xi  g. But for the LP solution described, C is empty and is not a feasible solution to the vct instance. If we set a new threshold of , we obtain a feasible solution from this LP solution, but we fail with the equally optimal solution given by x = x = x = , x = and yij = xi + xj . It is not clear that a threshold exists that will always produce a feasible solution. This is the motivation for a multi-phase approach. 2 3

1

1 2

2

1 3

1

2

3

3

1 6

1 3

4

4

1 2

2 3

5 6

3 The First Algorithm

The rst algorithm begins by solving the linear program (P 1) to obtain a value x0i for each vertex vi and a value yij0 for each edge (vi; vj ). The next three phases form the sets C ; C ; C respectively and together these sets are output as the cover. As we place vertices in these sets, we will work with the subgraph induced on the remaining vertices. The combined value of the remaining vertices will be used as a guide for the number of vertices to put in the cover. The combined value of the remaining edges will be used as an upper bound on the number of edges that remain to be covered. In phase 1 we use a threshold of and form C = fvi j x0i  g. In phase 2 we work with the subgraph induced on the vertices in V n C . Note that at this phase, each vertex has x0i < and each edge observes yij0 = x0i + x0j . We perform a series of adjustments to the values x0` and yij0 as follows. Two distinct vertices vr and vg are chosen with x0r > 0 and x0g > 0. We will donate a portion of the value of x0g to x0r . The values y`k0 will 1

2

3

1 2

1

1 2

1

1 2

4

be adjusted to maintain the equality y`k0 = x0` + x0k for P all edges in the current subgraph. The choice of vr and vg will be made such that the sum y`k0 does not decrease as a result of the adjustment. After an adjustment, the value x0r may be increased to . If so, vr is placed in C and is removed from the subgraph. The reader will note that the adjusted values mayP no longer formP a valid solution to the linear program. It is only necessary that we keep the sums !(vi)x0i and y`k0 from decreasing. Phase 2 continues until there are no longer two vertices vr ; vg in the current subgraph with 0 xr > 0 and x0g > 0. If C [ C covers fewer than t edges, then one vertex is placed in C . The algorithm is given below. We use the notation d0(vi) to denote the degree of vi in the current subgraph. 1 2

1

2

2

3

Algorithm ALG1

Input: G = (V; E ); ! : V ! f1; 2; : : : ; B; 1g; t Phase 0: If jf(u; v) 2 E j !(u) 6= 1 or !(v) 6= 1gj < t then return V ; terminate Else continue Solve the linear program (P 1) to get x ; : : : ; xn and fyij j (vi; vj ) 2 E g. Copy these values to x0 ; : : : ; x0n and fyij0 j (vi; vj ) 2 E g. Phase 1: C fvi j x0i  g Let (V 0 ; E 0) be the induced subgraph on V 0 = V n C Let d0(vi) be the degree of vertex vi in (V 0 ; E 0) Phase 2: C ; While 9 distinct vr and vg in V 0 with x0r > 0, x0g > 0 and d! vvrr  d! vvgg do  minf ? x0r ; !! vvgr x0g g x0r x0r +  x0g x0g ? !! vvgr  For each edge (v`; vk ) 2 E 0 do y`k0 x0` + x0k If x0r  then C C [ fvr g Remove vr and adjacent edges from (V 0; E 0) Update d0(vk ) for all vk in the new subgraph (V 0; E 0) Phase 3: If 9vi with x0i > 0 and C [ C covers < t edges then C fvig Else C ; Output: C [ C [ C 1

1

1 2

1

1

2

0

1 2

(

)

(

)

(

)

(

)

1 2

2

2

1

2

3

3

1

2

3

5

(

)

(

)

0

(

)

(

)

3.1 Analysis

In analyzing ALG1, we examine each phase separately. For phases 1 and 2, we will compare the size of Ci with the total vertex value eliminated in that phase. Similarly the size of C will be compared with the total vertex value of the last subgraph. We will employ the following notation. x0i and yij0 will refer to the nal values in the algorithm. V = CX V = C V = V ? (C [ C ) 0 w(vi)xi for k 2 f1; 2; 3g Wk = 3

1

E E E Yk

1 2 3

1

2

2

3

1

2

vi 2Vk

= f(vi; vj ) 2 E j vi 2 V or vj 2 V g = f(vi; vj ) 2 E j vi 2 V or vj 2 V g n E = f(vi; vj ) 2 E j vi 2 V and vj 2 V g X 0 yij for k 2 f1; 2; 3g. = 1

1

2

2

3

1

3

v ;vj )2Ek

( i

Recall also that

LB (G; !; t)  OPT (G; !; t): It should be clear that V ; V and V are disjoint sets and V [ V [ V = V . Also, E ; E and E are disjoint sets with E [ E [ E = E . We begin with an observation and some lemmas that will be used to establish our rst result. Observation If there exists no solution that covers t edges without using at least one vertex with in nite weight, then OPT = 1 and any in nite solution will do. Hence V , as output by 1

3

1

2

3

2

1

2

3

1

2

3

the algorithm is an optimal solution. If the set of edges adjacent to the nite-weight vertices is at least t, then there is a feasible, nite solution (i.e., the set of vertices with nite weight) and hence OPT is nite. In this case, for all in nite-weight vertices vq , the linear program will return xq = 0 and nowhere in the algorithm will vq be included in C1 [ C2 [ C3 . Thus no vertex in C1 [ C2 [ C3 will have weight larger than B . For the remainder of the paper we will assume we are working with instances that have nite optimal solutions. Lemma 1 The running time of ALG1 is polynomial in the input size. Proof of lemma 1: For phase 0 we have several polynomial-time algorithms to choose from for solving the linear program. Phase 1 is clearly polynomial. In phase 2 we need to show that only a polynomial number of iterations of the while loop are required. Note that for each iteration, x0r will become 21 and vr will be removed from the graph or x0g will become 0 and will not be considered again. Thus the number of vertices to consider is reduced by one each iteration. Therefore n is an upper bound on the number of iterations performed by the while loop before phase 2 terminates. The work done in each iteration is clearly polynomial. So phase 2 runs in polynomial time. Phase 3 can clearly be done in polynomial time. Therefore the algorithm runs in polynomial time.

6

Lemma 2 With each iteration in phase 2, the total value of the objective function does not n n change, i.e.,

X i=1

!(vi)xi =

X i=1

!(vi)x0i = W + W + W . 1

2

3

Proof of lemma 2: With each iteration,  is added to x0r and !! vv  is subtracted from x0g . The ( r)

net change to the objective function is

( g)

 !(v ) 

!(vr ) ? !(vg ) !(vr )  = 0: g Lemma 3 For all (vi ; vj ) 2 E , yij0  1.

Proof of lemma 3: We look separately at edges from E and those in E [ E . For edges (vi; vj ) 2 E , yij0 retains the original value from the linear program, i.e., yij0 = yij and thus yij0  1 1

2

3

1

by a constraint of the linear program. For edges (v`; vk ) 2 E [ E , note that at the beginning of phase 2, y`k0  1. A value y`k0 only increases if x0` or x0k is also increased. Only one value x0r is increased per iteration. We just need to show that for all vk adjacent to vr , yrk0  1 after the adjustment. Then a simple inductive proof (coupled with the fact that vr is removed from (V 0; E 0) when x0r = ) will show that yrk0  1 after a series of adjustments. We will use the superscripts before and after to denote the values before and after an adjustment. 2

3

1 2

yrkafter = xafter + xafter r k after before = xk + xr +  ! vg before before Since  = minf ? xr ; ! vr xg g,  xafter + xbefore + ( 1 ? xbefore ) r k 2 r Since x0k stays the same or is decreased (if k = g),  xbefore +1 k 2 Since vk has not yet been added to the cover, < 12 + 21 = 1 Therefore yrk0 remains smaller than 1 during each iteration. Note also that if x0r becomes then (vr ; vk ) is removed from (V 0 ; E 0) and yrk0 will not be altered again. The next lemma followsPfrom the observation that the adjustments are always made in a manner such that the sum yij0 does not decrease. 1 2

(

)

(

)

1 2

Lemma 4

X

v ;vj )2E

yij  Y + Y + Y . 1

2

3

( i

7

Proof of lemma 4: We begin with yij0 = yij . There are d0(vr ) edges adjacent to vr that are 0(vg ) edges adjacent to vg that are decreased by ! v  . Since d v  d v , increased by  and d !v !v !v P 0

( r)

( g)

yij0 is

the net eect to

d0(v

r

) + d0(v

( r)

( r)

0

( g)

( g)

 !(v )  0 r 0 (v ) ? d (vr ) ! (v )   d g) ? r !(vg ) !(vr ) r = 0

So the net eect is never a decrease. Thus we always have

X v ;vj )2E

X

yij 

v ;vj )2E

( i

yij0

( i

Since E ; E ; E are disjoint and E [ EX[ E = E , X yij0 + yij0 + = 1

2

3

1

2

X

3

v ;vj )2E2

v ;vj )2E1

( i

( i

= Y +Y +Y 1

2

v ;vj )2E3

yij0

( i

3

The next lemma will be used in determining how many edges are covered by C [ C [ C . 1

2

3

Lemma 5 If jC j > 0, then the number of edges in E covered by C is at least Y . Proof of lemma 5: Note that C can contain at most one vertex. If C = fvig for some i, then we had 0 < x0i < . For each vj 2 V that is adjacent to vi, we have x0j = 0 as a condition of the termination of phase 2. For edges (vk ; v`) 2 E not adjacent to vi , we have yk`0 = 0 since yk`0 = x0k + x0`. For edges (vi; vj ) 2 E (there are d0(vi) of them) we have yij0 = x0i < . Thus we have Y  d0(vi)=2. Since C covers d0(vi) new edges, we have the relationship Edges in E covered by C  2Y  Y ; 3

3

3

3

1 2

3

3

3

3

1 2

3

3

3

3

3

3

3

Lemma 6 establishes the feasibility of solutions produced by the algorithm.

Lemma 6 Solutions produced by ALG1 cover at least t edges. Proof of lemma 6: We have three cases that may occur in phase 3. 1. C = ; because C [ C covers t edges, 2. C = ; because all remaining vi have x0i = 0, 3. C = fvig. 3

1

2

3

3

The rst case is trivial. For the second case note that all uncovered edges have yij0 = x0i + x0j = 0. Hence Y = 0. Since C is empty, we can say that the number of edges in E covered by C is 3

3

3

8

3

Y . For the third case, lemma 5 tells us that the number of edges in E covered by C is at least Y . Then for the last two cases we have Number of edges covered = jE j + jE j + edges in E covered by C By the discussion above,  j0E j + jE j +1Y 0 1 3

3

3

3

=

1

2

1

2

3

3

@ X 1A + @ X 1A + Y v ;vj )2E1

v ;vj )2E2

( i

Since yij0  1 by lemma 3,

3

3

( i

0 1 0 1 X X  @ yij0 A + @ yij0 A + Y v ;vj )2E1

v ;vj )2E2

( i

= Y +Y +Y 1

By lemma 4,

X



From a constraint of the linear program,

2

v ;vj )2E

3

( i 3

yij

( i

 t

Lemma 7 Suppose that C = fvig. Then x0i has a lower bound of 1=d0(vi). Proof of lemma 7: Suppose that C = fvig. This means that jE j + jE j < t. Since t is an integer, we have jE j + jE j  t ? 1. But this implies Y + Y  t ? 1 since by lemma 3 we have X X 1 = jE j + jE j  t ? 1: 1+ Y +Y  3

3

1

1

2

1

1

2

v ;yj )2E1

( i

v ;vj )2E2

2

2

1

2

( i

By lemma 4 and a constraint of the linear program we have Y + Y + Y  t. This implies that Y  1. Now, recall that only vi has x0i > 0. All other vertices vj 2 V have x0j = 0. Since y`k0 = x0` + x0k , we have yik0 = xi for all edges adjacent to vi and y`k0 = 0 for non-adjacent edges. Then Y = d0(vi)x0i  1. This gives us a lower bound of x0i  1=d0(vi). The next lemma has a simple proof. Lemma 8 The three sets that make up the cover observe the following: !(C )  2W ; !(C )  2W ; !(C ) < 2W + B: Proof of lemma 8: The rst two inequalities follow from the fact that a vertex vi is only placed in C or C if x0i  . For the last inequality, there are two cases. Either C = ; or C = fvig. In the rst case !(C ) = 0 and clearly the inequality holds. In the second case we have !(C ) = !(vi) = 2!(vi)x0i + !(vi)(1 ? 2x0i ) By our rst observation, !(vi)  B , 1

2

3

3

3

3

1

1

2

1

2

2

1 2

3

3

3

3

3

9

3

 2!(vi)x0i + B (1 ? 2x0i)

By lemma 7,

 2!(vi)x0i + B (1 ? 1=d0(vi)) = 2W + B (1 ? 1=d0(vi)) 3

Since 1=d0(vi ) > 0,

< 2W + B 3

Now we can determine the performance ratio for ALG1.

?




B ? -approximation algorithm for vct with arbitrary weights and Theorem 1 ALG1 is a 2 + OP T 1

a 2-approximation algorithm for vct with unit weights.

Proof: By lemma 1, ALG1 runs in polynomial time. By lemma 6, it covers the required number of edges. We will now show that !(C [ C [ C )  2OPT (G; !; t) + B ? 1. 1

2

3

Since C ; C ; C are disjoint, !(C [ C [ C ) = !(C ) + !(C ) + !(C ) From lemma 8, < 2(W + W + W ) + B From lemma 2, n X = 2 !(vi)xi + B 1

2

3

1

2

3

1

1

From the linear program,

2

2

3

3

i=1

= 2LB (G; !; t) + B  2OPT (G; !; t) + B

Now !(C [ C [ C ) must be an integer, and thus it must not exceed the greatest integer k with k < 2OPT (G; !; t) + B . Since OPT (G; !; t) and B are both this implies ? integers, B ?
-approximation !(C [ C [ C )  2OPT (G; !; t) + B ? 1. Therefore ALG1 is a 2 + OP T algorithm for vct. When the instance is restricted to unit weights, B = 1 and ALG1 is a 2-approximation algorithm. 1

1

2

2

3

1

3

4 The Second Algorithm While ALG1 provides a good approximation for vct with unit weights, it may give a poor approximation in the general case since B may be arbitrarily larger than OPT . In our second algorithm we show how to tighten this bound, giving a 2-approximation algorithm for vct with arbitrary weights. To do this, we search for a vertex vp such that vp 2 Copt for some optimal cover Copt and !(vp) is the largest vertex weight in Copt. It is not necessary that vp is positively identi ed. We simply identify a set of vertices that are guaranteed to contain vp and create a cover for each potential vp. We then return the cover with the smallest weight. The algorithm is given below. 10

Algorithm ALG2

Input: G = (V; E ); ! : V ! f1; 2; : : : ; B g; t Order V by decreasing weight: !(v )  !(v ) 


 !(vn) For i 1; : : : ; jV j do Gi G n fvig For j 1; : : : ; i ? 1 do !i(vj ) 1 For j i; : : : ; jV j do !i(vj ) !(vj ) ti t ? d(vi) Ci ALG1(Gi ; !i; ti) [ fvig Find k such that !(Ck ) = minf!(C ); : : : ; !(Cn)g Return Ck 1

2

1

4.1 Analysis of ALG2

First we show that ALG2 produces a feasible solution.

Lemma 9 For all i 2 f1; : : : ; ng, Ci covers t edges. Proof of lemma 9: ALG1 is guaranteed to cover at least ti edges in graph Gi and also in G

(since Gi is a subgraph of G). Graph Gi doesn't contain edges adjacent to vi so adding vi to the cover increases the number of covered edges in G by d(vi). Thus the total number of edges in G covered by Ci is ti + d(vi) = t. The next lemma will be used to prove the approximation ratio of ALG2.

Lemma 10 Let Copt be an optimal t-cover for instance G; !; t and let vp be the vertex of largest weight in Copt . Then 1. OPT (G; !; t) = OPT (Gp; !p; tp ) + !(vp), and 2. !(Cp)  2OPT ? 1.

Proof of lemma 10: Since we are given that Copt contains vp and covers at least t edges then Copt n fvpg covers at least t ? d(vp) = tp edges. So Copt n fvpg is feasible for Gp; !p; tp and has weight !p(Copt) ? !p(vp). Then OPT (G; !; t) = !(Copt) ? !(vp) + !(vp) Since !(vi) = !p(vi) for all vi 2 Copt, = [!p(Copt) ? !p(vp)] + !(vp)  OPT (Gp; !p; tp) + !(vp) 11

Now, let C^opt be an optimal solution for Gp; !p; tp. So C^opt covers tp edges in Gp. Since vp and adjacent edges are not in Gp, C^opt [ fvpg covers tp + d(vp) = t edges in G. So C^opt [ fvpg is feasible for G; !; t. Then we have OPT (Gp; !p; tp) + !(vp) = !p(C^opt) + !(vp) Since !(v)  !p(v) for all v 2 V ,  !(C^opt) + !(vp)  OPT (G; !; t) Thus we have proved OPT (G; !; t) = OPT (Gp; !p; tp) + !(vp). For the second part we have

!(Cp) = !(ALG1(Gp; !p; tp)) + !(vp) But ALG1 guarantees  [2OPT (Gp; !p; tp) + B ? 1] + !(vp) Since B = !(vp), = 2OPT (Gp; !p; tp) + !(vp) ? 1 + !(vp) From the rst part of this lemma, = 2(OPT (G; !; t) ? !(vp)) + !(vp) ? 1 + !(vp) = 2OPT (G; !; t) ? 1 We now reach our main result.

Theorem 2 ALG2 is a 2-approximation algorithm for vct . Proof: It should be clear that ALG2 runs in polynomial time and by lemma 9 the set Ck

covers t edges. Now, obviously for any optimal t-cover Copt of an instance G; !; t there exists a vertex vp that has maximum weight in Copt and vp is identi ed in one of the iterations of ALG2 (iteration p). For that iteration, lemma 10 states that we produce a cover Cp with !(Cp)  2OPT (G; !; t) ? 1. But since !(Ck ) = minf!(C ); : : : ; !(Cn)g we have !(Ck )  !(Cp) and hence !(Ck)  2OPT (G; !; t) ? 1. Therefore ALG2 is a 2-approximation algorithm for vct . 1

To evaluate our result, we compare vct to vertex cover. As theorem 3 shows, their approximability is directly related.

Theorem 3 For functions t such that t? (jV j) (or t? (jE j)) is polynomial in jV j, there is an 1

1

approximation-preserving reduction from vertex cover to vct such that the existence of an -approximation algorithm for vct implies an -approximation algorithm for vertex cover.

Proof: We will prove the case when t is a function of jE j. The proof for t a function of jV j

follows easily. Let G = (V; E ); ! be an arbitrary instance of vertex cover and let its optimal cover size be denoted OPT (G; !). We create an instance G0 of vct from G by adding a matching M containing s edges on 2s new vertices. For each of these new vertices we assign a weight 12

equal to the maximum weight of a vertex in G. We choose s such that t(jE j + s) = jE j, i.e., s = t? (jE j) ? jE j. The new instance has polynomial size as long as t? (jE j) is polynomial in jV j. Certainly any vertex cover of G is a t-cover for G0 and has the same total weight. Thus OPT (G0; !; t)  OPT (G; !). Now, suppose C is a t-cover of G0. Then C covers t(jE j + s) = jE j edges. Let m = jC \ M j. The m vertices from C \ M can cover at most m edges in M and this leaves at most m edges in the subgraph G uncovered (since the total edges covered is jE j). Let C^ = C n M and then add to C^ one endpoint for each edge left uncovered in subgraph G. Since each vertex in G has weight no greater than a vertex in M , we have !(C^ )  !(C ). Now, given an -approximation algorithm for vct , an -approximation algorithm for vertex cover works as follows: It rst transforms the instance of vertex cover to one of vct by adding an appropriate-sized matching with large weights, then it applies the -approximation algorithm for vct and nally it transforms the output C to C^ by replacing vertices in C \ M with vertices in G as described above. Then we have !(C^ )  !(C )  OPT (G0; !; t)  OPT (G; !): 1

1

Therefore we have an -approximation for vertex cover. It is a direct consequence of the proof of theorem 3 that any lower bound for vertex cover is also a lower bound for vct for these values of t. Thus, following the result of Hastad [Ha97], we have the following. Corollary Unless P = NP, there can exist no -approximation algorithm for vct with  < . 7 6

5 Conclusions We have demonstrated a new technique of massaging a linear programming solution to give good approximate solutions for an interesting generalization of the vertex cover problem. This method may prove useful to other graph problems for which the linear programming solutions may not appear to have a direct interpretation.

References [BE85] R. Bar-Yehuda and S. Even. A local-ratio theorem for approximating the weighted vertex cover problem. Annals of Discrete Mathematics vol 25, (1985), 27-45. [GW94a] M. Goemans and D. Williamson. :878-Approximation Algorithms for MAX CUT and MAX 2SAT. Proceedings of the Twenty-Sixth Annual ACM Symposium on the Theory of Computing (1994), 422-431. [GW94b] M. Goemans and D. Williamson. New 3=4-Approximation Algorithms for MAX SAT. SIAM Journal of Discrete Mathematics, 7 (1994), 656-666. [Ha97] J. Hastad. Some Optimal Inapproximability Results. To appear in the Proceedings of the Twenty-Ninth Annual ACM Symposium on the Theory of Computing (1997). 13

[Ho82] D. Hochbaum. Approximation Algorithms for Set Covering and Vertex Cover Problems. SIAM Journal on Computing 11 (1982), 555-556. [KMS94] D. Karger, R. Motwani and M. Sudan. Approximate Graph Coloring by Semide nite Programming. 35th Annual Symposium on Foundations of Computer Science (1994) 2-13. [Ka84] N. Karmarkar. A New Polynomial-Time Algorithm for Linear Programming. Combinatorica vol 4, (1984), 373-395. [Kh79] L. Khachian. A polynomial algorithm for linear programming. Doklady Akad Nauk USSR, vol 244(5) (1979), 1093-1096. [KG95] J. Klienberg and M. Goemans. The Lovasz Theta Function and a Semide nite Programming Relaxation of Vertex Cover. To appear in SIAM Journal on Discrete Mathematics. [RT87] P. Raghavan and C. Thompson. Randomized Rounding: A Technique for Provably Good Algorithms and Algorithmic Proofs. Combinatorica, 7 (1987) 365-374.

14