Algorithm Design

636
Chapter !! Approximation Algorithms
(11.23) Let S* denote a vertex cover o] ~ minimum tveight. Then tvLp < w(S*).
Proof. Vertex covets of G correspond to integer solutions of (VC.IP)~ so the
minimum of nfin(tvtx : -i >_ x >_ O, Ax >_ !) over all integer x vectors is exactly
the minimum-weight vertex cover. To get the minimum of the linear program
(VC.LP), we allow x to take arbitrary real-number values--that is, we minimize
over many more choices of x--and so the minimum of (VC.LP) is no larger
than that of (VC.IP). []
Note that (11.23) is one of the crucial ingredients we need for an approximation
algorithm: a good lower bound on the optimum, in the form of the
efficiently computable quantity tvLp.
However, tvLp Can definitely be smaller than tv(S*). For example, if the
graph G is a triangle and all weights are 1, then the minimum vertex cover has
a weight of 2. But, in a linear programming solution, we can set xi = ½ for 3 AS all
three vertices, and so get a linear programming solution of weight only ~.
a more general example, consider a graph on n nodes in which each pair of
nodes is connected by an edge. Again, all weights are 1. Then the minimum
vertex cover has weight n - 1, but we can find a linear programming solution
of value n/2 by setting xi = } for all vertices i.
So the question-is: How can solving this linear program help us actually
find a near-optimal vertex cover? The idea is to work with the values x~ and
to infer a vertex cover S from them. It is natural that ¯ if x~ = 1 for some node i,
then we should put it in the vertex cover S; and if * x 0
i = , then we should leave
it out of S. But what should we do with fractional values in between? What
¯
should we do if x .4 or * .5? The natural approach here is to round¯
i = xi =
¯ Xi --
Given a fractional solution {x~}, we define S = {i ~ V" * > }}--that is, we
rotmd values at least } up, and those below } down¯
(11.24) The set S defined in this tray is a vertex cover, and tv(S)< tvLp.
Proof. First we argue that S is a vertex cover. Consider an edge e ---- (i, ]). We
claim that at least one of i and] must be in S. Recall that one of our inequalities
is xi + xj > 1. So in any solution x* that satisfies this inequality, either x~ > }
or x~* > }. Thus at least one of these two will be rounded up, and i or ] will be
I -placed
in S.
Now we consider the weight iv(S) of this vertex cover. The set S only has
vertices with x~ > }; thus the linear program "paid" at least }tvi for node i, and
we only pay tvi: at most twice as much. More formally, we have the following
chain of inequalities.
i ieS ieS
11.7 Load Balancing Revisited: A More Advanced LP Application
Thus we have a produced a vertex cover S of weight at most 2tvLp. The
lower bound in (11.23) showed that the optimal vertex cover has weight at
least tvL~, and so we have the following result.
(11.25) The algorithm produces a vertex cover S o~at most ttvi~e th~ minimum
possible tvelght.
* 11.7 Load Balancing Revisited: A ~ore Advanced
LP Application
In this section we consider a more general load balancing problem. We will
develop an approximation algorithm using the same general outline as the 2approximation
we iust designed for Vertex Cover: We solve a corresponding
linear program, and then round the solution. However, the algorithm and its
analysis here will be significantly more complex than what was needed for
Vertex Cover. It turns out that the instance of the Linear programming Problem
we need to solve is, in fact, a flow problem. Using this fact, we will be able
to develop a much deeper understanding of what the fractional solutions to
the linear program look like, and we will use this understanding in order to
round them. For this problem, the only known constant-factor approximation
algorithm is based on rounding this linear programming solution.
~ The Problem _
The problem we consider in this section is a significant, but natural, generalization
of the Load Balancing Problem with which we began our study of
approximation algorithms. There, as here, we have a set J of n jobs, and a set
M of m machines, and the goal is to assign each job to a machine so that the
maximum load on any machine will be as small as possible. In the simple Load
Balancing Problem we considered earlier, each job j can be assigned to any
machine i. Here, on the other hand, we will restrict the set of machines that
each job may consider; that is, for each job there is just a subset of machines
to which it can be assigned. This restriction arises naturally in a number of
applications: for example, we may be seeking to balance load while maintaining
the property that each job is assigned to a physically nearby machine, or
to a machine with an appropriate authorization to process the job.
More formally, each jobj has a fixed given size t] > 0 and a set of machines
M~ ___ M that it may be assigned to. The sets ~ can be completely arbitrary.
We call an assignment of jobs to machines feasible if each job j is assigned to
a machine i e M]. The goal is still to minimize the maximum load on any
machine: Using Ji _c J to denote the jobs assigned to a machine i e M in
a feasible assignment, and using L~ = ~]~j; t] to denote the resulting load,
637