Operations Research Letters 36 (2008) 157–159

OperationsResearchLetters

www.elsevier.com/locate/orl

An approximation algorithm for identical parallel machine scheduling withresource dependent processing times

Hans KellererInstitut für Statistik und Operations Research, Universität Graz, Universitätsstraße 15, A-8010, Graz, Austria

Received 25 October 2006; accepted 9 August 2007Available online 8 September 2007

Abstract

We present a (3.5 + ε)-approximation algorithm for a scheduling problem on identical parallel machines with the objective to mimimizethe makespan. The processing times depend on the usage of a single renewable resource where at any point of time at most k units from theresource are available.© 2007 Elsevier B.V. All rights reserved.

Keywords: Scheduling; Resource constraints; Multiple choice knapsack

1. Introduction

In this paper we consider a parallel machine scheduling prob-lem with resource dependent processing times, i.e., the process-ing time of a job depends on the amount of an additional singleresource assigned to that job. We assume the machines areidentical, i.e. the processing time of a job does not depend onthe machine assignment but on the resource consumption only.

Formally, we are given a set N = {1, 2, . . . , n} of n jobs andm processing machines 1, . . . , m. Each job has to be processedon exactly one machine. No machine processes more than onejob at a time and preemption is not allowed.

It is assumed that a job may consume an additional renewableresource. There are k�1 units of the resource available at anytime. Consequently, a set of jobs can only be processed inparallel when the simultaneous total resource consumption doesnot exceed k. Let s ∈ {0, . . . , k}. If s units of the resource areassigned to job j, its processing time becomes pjs . Notice thatthe resource consumption of a job remains the same during theentire processing of that job.

The goal is to find a schedule that minimizes the makespan,i.e., the maximum completion time. For a schedule S, let themakespan be denoted by Cmax(S). A schedule with the smallestmakespan is called optimal and is denoted by S∗.

E-mail address: hans.kellerer@uni-graz.at

0167-6377/$ - see front matter © 2007 Elsevier B.V. All rights reserved.doi:10.1016/j.orl.2007.08.001

For the scheduling problem an approximation algorithm isgiven. The quality of approximation algorithms is measured bytheir worst-case performance ratios. An algorithm H that createsa schedule SH is said to provide a worst-case performance ratio� or is called an �-approximation algorithm, if for any instanceof the problem the inequality Cmax(SH )/Cmax(S

∗)�� holds.A family of (1 + ε)-approximation algorithms is called a fullypolynomial-time approximation scheme FPTAS, if for any ε > 0the running time is polynomial with respect to both the lengthof the input and 1/ε.

Grigoriev et al. [2] show that the problem cannot be approx-imated within a factor smaller than 3

2 , unless P =NP holds. Inthe same paper a 3.75-approximation algorithm was presentedfor the generalization to unrelated machines, i.e. in the casethat processing times are also machine dependent.

In this paper we will derive a (3.5 + ε)-approximation algo-rithm for identical parallel machines with resource dependentprocessing times thus improving the 3.75-approximation algo-rithm in [2] in the case of identical machines. The algorithmsis based on an integer programming relaxation which can beformulated as a multiple choice knapsack problem.

2. A (3.5 + �)-approximation algorithm for identicalparallel machines

In this section we show that the problem of parallel identicalmachines with resource dependent processing times admits an

158 H. Kellerer / Operations Research Letters 36 (2008) 157–159

approximation algorithm with a worst-case performance ratio3.5 + ε for any ε > 0. The procedure follows partially the ap-proach in [1] where a (4 + 2

√2)-approximation algorithm was

presented for the problem of parallel identical machines withresource dependent processing times. The resource allocationis done through the approximative solution of an integer pro-gramming relaxation. The corresponding FPTAS is based on avariation of the multiple choice knapsack problem. The jobsare allocated to the machines using a variation of the Greedyalgorithm.

For a given schedule length C a processing time pjs is calledlong if pjs > C/2 and s�k/2 hold. Analogously, long jobs arethose jobs to which a long processing time is assigned. Obvi-ously, an optimal schedule S∗ with makespan C = Cmax(S

∗)contains at most m long jobs. Consider the following integerlinear programming problem (PP) which is an enhancement ofthe model in [1]: an aggregate version of the machine load con-straints is used and a condition on the number of long jobs isadded.

n∑

j=1

k∑

s=0

spjsxjs �kC, (1)

n∑

j=1

k∑

s=0

pjsxjs �mC, (2)

k∑

s=0

xjs = 1, j = 1, . . . , n, (3)

∑

pjs>C/2

xjs �m, (4)

xjs = 0, if pjs > C, (5)

xjs ∈ {0, 1}. (6)

We set xjs = 1 if s units of the resource are assigned to job jand xjs = 0, otherwise. Constraint (1) guarantees that the totalresource consumption does not exceed kC and constraint (2)makes sure that the total processing time of the jobs is notgreater than mC. Finally, inequalities (4) and (5) ensure that nomore than m long jobs are selected by the integer program andthat there is no job with processing time greater than C.

Problem PP is turned from a feasibility problem into a min-imization problem by defining program (PPa).

Minimizen∑

j=1

k∑s=0

spjsxjs

such thatn∑

j=1

k∑s=0

pjsxjs �mC,

∑pjs>C/2

xjs �m,

k∑s=0

xjs = 1, j = 1, . . . , n,

xjs = 0, if pjs > C,

xjs ∈ {0, 1}.

The given program is a multiple choice knapsack problem(MCKP) in minimization form with the additional constraint(4). The MCKP is a generalization of the classical knapsackproblem. We have given t mutually disjoint classes M1, . . . , Mt

of items to be packed into a knapsack of capacity C. Each items ∈ Mj has a cost cjs and a weight wjs , and the problem isto choose exactly one item from each class such that the totalcost sum is minimized without exceeding the capacity C in thecorresponding weight sum.

In our case, t = n and Mj = {0, . . . , k}, j = 1, . . . , n. Recallthat set {0, . . . , k} corresponds to the k + 1 different values ofthe resource which can be allocated to job j. The weights wjs

correspond to the processing times pjs , the costs cjs are equalto spjs and the capacity is equal to mC.

An FPTAS for the MCKP is shortly described in [3, p. 338].For developing an FPTAS for the MCKP we use dynamicprogramming by profits by using a recursion similar to the re-cursion used for the classical knapsack problem. The approachrelies on scaling of the profit values and running the recursionwith the scaled cost values c̃js := cjs/K with an appropri-ately chosen constant K. To achieve an accuracy of 1 + ε forthe MCKP an overall running time of O(t

∑tj=1|Mj |/ε) is

required.An FPTAS for the given generalization can be easily con-

structed. Instead of storing one state for each cost value in thescaled dynamic programming range as described in [3, p. 338],states are given for all pairs of cost values and numbers of longjobs been selected so far. This increases the running time by afactor of m but the rest of the approximation scheme remainsunchanged. Thus, program PPa can be approximated with per-formance ratio 1 + ε in O(mn2k/ε) time.

The FPTAS for PPa can be used in a binary search on Cto compute the smallest integer C∗ for which problem PPahas a solution x∗ with objective z∗ �(1 + ε)kC∗. The valueC∗ is a lower bound on the optimal makespan Cmax(S

∗).The corresponding solution vector x∗ is a feasible solutionof PP with the right-hand side of constraint (1) increased to(1 + ε)kC∗.

For assigning the jobs we use a simple variant of list schedul-ing. Among all non-assigned jobs assign the job with the earli-est possible starting time to the corresponding machine. If thereis more than one job with earliest possible starting time, alwayschoose a long job among these jobs.

Theorem 1. There is a (3.5 + ε)-approximation algorithm forthe problem with parallel identical machines and resource de-pendent processing times. The running time of the algorithm ispolynomial both in the length of the input and 1/ε.

Proof. We will show that the above described algorithm deliv-ers the claimed performance ratio of 3.5 + ε. Let T denote theunion of all time intervals where the total resource consump-tion at any time is at most k/2 and at least one machine is idlein the heuristic schedule. Denote with T1 = [s1, t1] the first ofthese time intervals. Let � denote the total length of the timeintervals in T. A job with resource consumption greater thank/2 is called a big job.

H. Kellerer / Operations Research Letters 36 (2008) 157–159 159

W.l.o.g. machine 1 is idle in the time interval [s1, t′1] with

t ′1 � t1. But that means that all jobs starting later than s1 arebig jobs, since otherwise they would be assigned to machine 1.Consequently, T = T1. Therefore, there is at most one job oneach machine which is processed during time interval T1. Sincethe jobs processed during interval T1 are not big, they must startnot later than s1 and there is at least one of these jobs whichdoes not finish before time t1. This job is called the idle job. Itsprocessing time is denoted by p, its starting time by � and itsprocessing interval [�; � + p] by I. Clearly, p�� and T ⊆ I .

The value � shall denote the total length of intervals exceptI where at most k/2 units of resource are assigned to jobs andno machine is idle. The value � denotes the total length ofintervals except I where more than k/2 units of the resourceare assigned to jobs.

The value of the heuristic solution SH is bounded byCmax(SH )�� + � + p. Due to (2) we have ��C∗.

Running the binary search on C for problem PPa until theobjective function is not greater than (1 + ε/2)kC∗ we getfrom the definition of � that k

2��(1 + ε/2)kC∗ holds. This isequivalent to ��(2 + ε)C∗ and

Cmax(SH )�(2 + ε)C∗ + � + p

follows.In case that p�C∗/2, the claim Cmax(SH )�(3.5 +

ε)Cmax(S∗) follows immediately from ��C∗.

If �= 0, i.e. I =[0, p] for the processing interval of the idlejob, we get � = 0 since only big jobs are processed after theidle job has been finished. Note that (5) implies that p�C∗.We conclude Cmax(SH )�(3 + ε)C∗.

Thus, assume in the following that � > 0 and p > C∗/2. Con-sequently, the idle job is a long job. Consider an arbitrary timet < � in the time interval [0; �[. At time t at least one machineis idle or at least one job processed at time t is not a long job,since due to (4) there are at most m long jobs and the idle job isstarted later. This means that the idle job could not be processedat time t, because according to the algorithm long jobs are al-ways preferred to other jobs if the schedule remains feasible.Therefore, more than k/2 units of the resource are assigned tojobs at any time in the interval [0; �). Recall that only big jobsare processed after the idle job has been finished. Again weconclude that � = 0 and Cmax(SH )�(3 + ε)C∗ follows. �

References

[1] A. Grigoriev, M. Sviridenko, M. Uetz, Unrelated parallel machinescheduling with resource dependent processing times, in: M. Jünger,V. Kaibel (Eds.), Integer Programming and Combinatorial Optimization(IPCO 2005), LNCS 3509, 2005, pp. 182–195.

[2] A. Grigoriev, M. Sviridenko, M. Uetz, Machine scheduling with resourcedependent processing times, Mathematical Programming B 110 (2007)209–228.

[3] H. Kellerer, U. Pferschy, D. Pisinger, Knapsack Problems, Springer, Berlin,2004.