Algorithm Design

616
Chapter 11 Approximation Algorithms
1
1/2
1/3
y = 1/x
Figure 11.7 Upper and lower bounds for the Harmonic Function H(n).
is no loss of generality in doing this, since it simply involves a renaming of the
elements in U.
Now consider the iteration in which element s 1 is covered by~e g,reedy
Sd ~ R by
our labeling of the elements. This implies that ISk r3 RI is at least d -] + 1, and
so the average cost of the set Sk is at most
Wk
ISknR -d-j+1
Note that this is not necessarily an equality, since sj may be covered in the
same iteration as some of the other elements sy for j’ < j. In this iteration, the
greedy algorithm selected a set S i of minimum average cost; so this set Si has
average cost at most that of S~. It is the average cost of S i that gets assigned
to sp and so we have
We now simply add up these inequalities for all elements s ~ S~:
d
]=1
Wk Wk
1 d
o
wt~ = H(d) . w k.
We now complete our plan to use the bound in (11.10) for comparing the
greedy algorithm’s set cover to the optimal one. Letting d* = max~ ISgl denote
the maximum size of any set, we have the following approximation result.
(11.11) The set cover e selected by Greedy-Set-Cover has weight at most
H (d*) times the optimal weight
11.3 Set Cover: A General Greedy Heuristic
Proof. Let e* denote the optimum set cover, so that w* = ~si~e* wi. For each
of the sets in e*, (11.10) implies
Because these sets form a set cover, we have
1
s~S i
s~U
Cs.
Combining these with (11.9), we obtain the desired bound:
w,= E w,_>E 1 " 1 1
E Cs > E Cs =- E w,. []
size* s~e* s~si - H(d*) s~U H(d*) Si~
Asymptotically, then, the bound in (11. !1) says that the greedy algorithm
finds a solution within a factor O(log d*) of optimal. Since the maximum set
size d* can be a constant fraction of the tota! number of elements n, this is a
worst-case upper bound of O(log n). However, expressing the bound in terms
of d* shows us that we’re doing much better if the largest set is small.
It’s interesting to note that this bound is essentially the best one possible,
since there are instances where the greedy algorithm can do this badly. To
see how such instances arise, consider again the example in Figure 11.6. Now
suppose we generalize this so that the underlying set of elements U consists
of two tall columns with n/2 elements each. There are still two sets, each of
weight 1 + ~, for some small e > 0, that cover the columns separately. We also
create O(log n) sets that generalize the structure of the other sets in the figure:
there is a set that covers the bottommost n/2 nodes, another that covers the
next n/4, another that covers the next rt/8, and so forth. Each of these sets
will have weight 1.
Now the greedy algorithm will choose the sets of size n/2, n/4, n/8 .....
in the process producing a solution of weight S2(!og n). Choosing the two
sets that cover the columns separately, on the other hand, yields the optimal
solution, with weight 2 + 2e. Through more complicated constructions, one
can strengthen this to produce instances where the greedy algorithm incurs
a weight that is very close to H(n) times t_he optimal weight. And in fact, by
much more complicated means, it has been shown that no polynomial-time
approximation algorithm can achieve an approximation bound much better
than H(n) times optimal, unless P = NP.
617