Algorithm Design

648
Chapter 11 Approximation Algorithms
The New Dynamic Programming Algorithm for the
Knapsack Problem
To solve a problem by dynamic programming, we have to define a polynomial
set of subproblems. The dynamic programming algorithm we defined when we
studied the Knapsack Problem earlier uses subproblems of the form OPT(i, w):
the subproblem of finding the maximum value of any solution using a subset of
the items 1 ..... i and a knapsack of weight w. When the weights are large, this
is a large set of problems. We need a set of subproblems that work well when
the values are reasonably small; this suggests that we should use subproblems
associated with values, not weights. We define our subproblems as follows.
The subproblem is defined by i and a target value V, and b-~(i, V) is the
smallest knapsack weight W so that one can obtain a solution using a subset
of items {1 ..... i} with value at least VI We will have a subproblem for all
i = 0 ..... n and values V = 0,.. i, ~=1 vi" If v* denotes maxi vi, then we see
that the largest V can get in a subproblem is ~=1 vj E n-~ -
i=~ vi, then-6-P~(n, V) = wn +-6-~(n !, V - vn). Otherwise
b-fir(n, V) = min(b-fff(n - !, V), w~ + b-fff(n - 1, max(0, V - vn))).
We can then write down an analogous dynamic programming algorithm.
Knapsack(n) :
Array M[0 ... n, 0... V]
For i = 0 ..... n
M[i, O] = 0
Endfor
For i=1,2 ..... n
For V = 1 ..... ~=I
v > vj then
M[i, V]=wi+M[i- 1, V]
Else
M[i, V]’= min(M[i - I~ V], m~ +~[f - I, m~(O, V - u~)])
Endif
~dfor
~or
Retu~ the m~im~ v~ue V such that ~[n, V]~ ~
Solved Exercises
(11.40) Knapsack(n) takes O(n~v *) time and correctly computes the-optimal
values of the subproblems.
As was done before, we can trace back through the table M containing the
optimal values of the subpmblems, to find an optimal solution.
Solved Exercises
Solved Exercise 1
Recall the Shortest-First greedy algorithm for the Interval Scheduling Problem:
Given a set of intervals, we repeatedly pick the shortest interval I, delete all
the other intervals I’ that intersect I, and iterate.
In Chapter 4, we saw that this algorithm does not always produce a
maximum-size set of nonoveflapping intervals. However, it turns out to hdve
the fol!owing interesting approximation guarantee. If s* is the maximum size
of a set of nonoverlapping intervals, and s is the size of the set produced
by the Shortest-First Algorithm, then s > ½s* (that is, Shortest-First is a 2approximation).
Prove this fact.
Solution Let’s first recall the example in Figure 4.1 from Chapter 4, which
showed that Shortest-First does not necessarily find an optimal set of intervals.
The difficulty is clear: We may select a short interval ] while eliminating two
longer flanking intervals i and i’. So we have done only half as well as the
optimum.
The question is to show that Shortest-First could never do worse than this.
The issues here are somewhat similar to what came up in the analysis of the
649