Design of Approximation Algorithms

74 Rounding data and dynamic programmingperformance in the following way. If we pair up bins 1 and 2, then 3 and 4, and so forth, thenany such pair must have the property that the total piece size in them is at least 1: in fact, thefirst item placed in bin 2k is put there only because it did not fit in bin 2k − 1. Thus, if weused l bins, then the total size of the pieces in the input, SIZE(I) = ∑ ni=1 a i, is at least ⌊l/2⌋.However, it is clear that OPT(I) ≥ SIZE(I), and hence, the number of bins used by First-Fitis FF(I) = l ≤ 2 SIZE(I) + 1 ≤ 2 OPT(I) + 1. Of course, this analysis did not use practicallyany information about the algorithm; we used only that there should not be two bins whosecontents can be feasibly combined into one bin.We shall present a family of polynomial-time approximation algorithms parameterized byϵ > 0, where each algorithm has the performance guarantee of computing a packing with atmost (1 + ϵ) OPT(I) + 1 bins for each input I. Throughout this discussion, we shall view ϵas a positive constant. Note that this family of algorithms does not meet the definition of apolynomial-time approximation scheme because of the additive constant. This motivates thefollowing definition.Definition 3.9: An asymptotic polynomial-time approximation scheme (APTAS) is a familyof algorithms {A ϵ } along with a constant c where there is an algorithm A ϵ for each ϵ > 0 suchthat A ϵ returns a solution of value at most (1 + ϵ) OPT +c for minimization problems.One of the key ingredients of this asymptotic polynomial-time approximation scheme isthe dynamic programming algorithm used in the approximation scheme for scheduling jobson identical parallel machines, which was presented in Section 3.2. As stated earlier, thatalgorithm computed the minimum number of machines needed to assign jobs, so that eachmachine was assigned jobs of total processing requirement at most T . However, by rescalingeach processing time by dividing by T , we have an input for the bin-packing problem. Thedynamic programming algorithm presented solves the bin-packing problem in polynomial timein the special case in which there are only a constant number of distinct piece sizes, and onlya constant number of pieces can fit into one bin. Starting with an arbitrary input to thebin-packing problem, we first construct a simplified input of this special form, which we thensolve by dynamic programming. The simplified input will also have the property that we cantransform the resulting packing into a packing for the original input, without introducing toomany additional bins.As in the scheduling result of Section 3.2, the first key observation is that one may ignoresmall pieces of size less than any given threshold, and can analyze its effect in a relatively simpleway.Lemma 3.10: Any packing of all pieces of size greater than γ into l bins can be extended to a1packing for the entire input with at most max{l,1−γSIZE(I) + 1} bins.Proof. Suppose that one uses the First-Fit algorithm, starting with the given packing, to computea packing that also includes these small pieces. If First-Fit never starts a new bin inpacking the small pieces, then clearly the resulting packing has l bins. If it does start a newbin, then each bin in the resulting packing (with the lone exception of the last bin started) mustnot have been able to fit one additional small piece. Let k + 1 denote the number of bins usedin this latter case. In other words, each of the first k bins must have pieces totaling at least1 − γ, and hence SIZE(I) ≥ (1 − γ)k. Equivalently, k ≤ SIZE(I)/(1 − γ), which completes theproof of the lemma.Suppose that we were aiming to design an algorithm with a performance guarantee that isbetter than the one proved for First-Fit (which is truly a modest goal); in particular, we areElectronic web edition. Copyright 2011 by David P. Williamson and David B. Shmoys.To be published by Cambridge University Press