Algorithm Design

600
Chapter 11 Approximation Algorithms
the study of linear programming, which can also be used to motivate this approach.
Our presentation of the pricing method here will not assume familiarity
with linear programming. We will introduce linear programming through our
third technique in this chapter, linear programming and rounding, in which
one exploits the relationship between the computational feasibility of linear
programming and the expressive power of its more difficult cousin, integer
programming. Finally, we will describe a technique that can lead to extremely
good approximations: using dynamic programming on a rounded version of
the input.
11.1
Greedy Algorithms and Bounds on the
Optimum: A Load Balancing Problem
As our first topic in this chapter, we consider a fundamental Load Balancing
Problem that arises when multiple servers need to process a set of jobs or
requests. We focus on a basic version of the problem in which all servers
are identical, and each can be used to serve any of the requests. This simple
problem is useful for illustrating some of the basic issues that one needs to
deal with in designing and analyzing approximation algorithms, particularly
the task of comparing an approximate solution with an optimum solution that
we cannot compute efficiently. Moreover, we’ll see that the general issue of
load balancing is a problem with many facets, and we’ll explore some of these
in later sections.
/..~ The Problem
We formulate the Load Balancing Problem as follows. We are given a set of m
Mrn and a set of n jobs; each job j has a processing time tj.
We seek to assign each iob to one of the machines so that the loa~ls placed on
al! machines are as "balanced" as possible.
More concretely, in any assignment of iobs to machines, we can let A(i)
denote the set of iobs assigned to machine Mi; under this assignment, machine
Mi needs to work for a total time of
j~A(i)
and we declare this to be the load on machine Mi. We seek to minimize a
quantity known as the makespan; it is simply the maximum load on any
machine, T = maxi Ti. Mthough we wil! not prove this, the scheduling problem
of finding an assignment of minimum makespan is NP-hard.
11.1 Greedy Algorithms and Bounds on the Optimum: A Load Balancing Problem
~ Designing the Mgorithm
We first consider a very simple greedy algOrithm for the problem. The algorithm
makes one pass through the jobs in any order; when it comes to jobj, it assigns
j to the machine whose load is smallest so far.
Greedy-Balance :
Start with no jobs assigned
Set T i=0 and A(0=0 for all machines Mi
For j=l .....
Let M i be a machine that achieves the minimum min/~ T k
Assign job j to machine M
Set A(i) *- A(i) U
Set Ti *- Ti + t j
EndFor
For example, Figure 11.1 shows the result of running this greedy algorithm
on a sequence of six jobs with sizes 2, 3, 4, 6, 2, 2; the resulting makespan is 8,
the "height" of the jobs on the first machine. Note that this is not the optimal
solution; had the jobs arrived in a different order, so that the algorithm saw
the sequence of sizes 6, 4, 3, 2, 2, )., then it would have produced an allocation
with a makespan of 7.
~ Analyzing the Mgorithm
Let T denote the makespan of the resulting assignment; we want to show that
T is not much larger than the minimum possible makespan T*. Of course,
in trying to do this, we immediately encounter the basic problem mentioned
above: We need to compare our solution to the optimal value T*, even though
we don’t know what this value is and have no hope of computing it. For the
M1
Figure 11.1 The result of running the greedy load balancing algorithm on three
machines with job sizes 2, 3, 4, 6, 2, 2,
601