J Sched (2013) 16:69–79DOI 10.1007/s10951-011-0255-8

Single machine batch scheduling with release times and deliverycosts

Esaignani Selvarajah · George Steiner · Rui Zhang

Published online: 18 October 2011© Springer Science+Business Media, LLC 2011

Abstract We study single machine batch scheduling withrelease times. Our goal is to minimize the sum of weightedflow times (or completion times) and delivery costs. Sincethe problem is strongly N P -hard even with no delivery costand identical weights for all jobs, an approximation algo-rithm is presented for the problem with identical weights.This uses the polynomial time solution we give for the pre-emptive version of the problem. We also present an evolu-tionary metaheuristic algorithm for the general case. Com-putational results show very small gaps between the resultsof the metaheuristic and the lower bound.

Keywords Scheduling · Batching · Release times ·Delivery costs · Single machine

1 Introduction

The classical single machine scheduling problem to mini-mize the sum of weighted flow times when jobs have distinctrelease dates is one of the well-studied problems in schedul-ing. In the three-field notation introduced by Graham et al.(1979), this problem is denoted by 1|rj |∑wjFj , where wj

is the weight and Fj = (Cj − rj ) is the flow time when the

E. SelvarajahOdette School of Business, University of Windsor, Windsor,ON, Canadae-mail: selvare@uwindsor.ca

G. Steiner (�) · R. ZhangDeGroote School of Business, McMaster University, Hamilton,ON, Canadae-mail: steiner@mcmaster.ca

R. Zhange-mail: zhangr6@mcmaster.ca

release time is rj and the completion time is Cj for job Jj ,for all j . Consider a single machine as a production system.Then the release time of a job is the time at which it arrivesin the system and the completion time of that job is the timeat which the processed job (or product) is ready to leave thesystem. The weighted flow times can be interpreted as hold-ing costs (or inventory costs). In most cases, there are deliv-ery costs associated with transferring jobs from one systemto another or to the customer. Thus, products are deliveredto customers in batches in order to save on the delivery costwhile making sure the inventory holding cost of productswaiting for the delivery does not cancel the savings in thedelivery cost. This type of model reflects the trade-off be-tween in-house inventory costs and logistics costs.

There are many papers on batch scheduling when there isa setup time needed at the beginning of each batch. Coffmanet al. (1990) study the batch-scheduling problem to mini-mize the sum of the completion times for jobs with arbi-trary processing times when there is a constant setup timeat the start of each batch. In batch scheduling, the com-pletion time of a job is defined by the completion time ofthe last job in the same batch. Thus, the flow time is de-termined by the redefined completion time and the releasetime of the job. From now on, we use these two definitionsfor the completion and flow time in the context of batchscheduling. Coffman et al. (1990) present an O(N) algo-rithm for the optimal batching of any given sequence of N

jobs. They further prove that in the optimal batching sched-ule, jobs are ordered in shortest-processing-time (SPT) orderto minimize the sum of completion times. Since the SPT jobsequence can be obtained in O(N logN) time, they are ableto solve this batch-scheduling problem in O(N logN) time.Albers and Brucker (1993) extend this study and prove thatthe optimal batching of jobs with identical processing timesand arbitrary weights can be solved in O(N logN) time,

70 J Sched (2013) 16:69–79

and the optimal batching of jobs with arbitrary processingtimes and arbitrary weights for any given job sequence canalso be solved in O(N) time. Readers may want to referto survey papers on batch scheduling by Potts and Kova-lyov (2000), Allahverdi et al. (1999) and Allahverdi et al.(2008). In this paper, we study the batch-scheduling problemof minimizing the sum of weighted flow times and batch-delivery costs when jobs have release times and a fixedbatch-delivery cost for each batch. This problem is denotedby 1|rj |∑wjFj + nd , where n is the number of batchesand d is the batch-delivery cost.

Smith (1956) proves that Weighted-Shortest-Processing-Time (WSPT) job sequence, non-decreasing order of

pj

wj,

is optimal for the problem 1||∑wjCj , where pj is theprocessing time of job j . The problem with arbitrary re-lease times, however, is known to be strongly N P -hardeven for the unweighted case 1|rj |∑Cj (Lenstra et al.1977). Chekuri et al. (2001) provide a 1.58-approximationalgorithm for this problem. The preemptive version 1|rj ,pmtn|∑Cj , where “pmtn” implies that jobs can be inter-rupted any time during their processing, is solvable by theshortest-remaining-processing-time (SRPT) rule (Schrage1968). The weighted problem 1|rj ,pmtn|∑wjCj , how-ever, is strongly N P -hard (Labetoulle et al. 1984). Goe-mans et al. (2000) develop a 1.47-approximation algorithmfor 1|rj ,pmtn|∑wjCj . Afrati et al. (1999) present a poly-nomial time approximation scheme for the non-preemptiveversion of the problem on single and parallel machines. Theproblem becomes more difficult, however, for the weighted

flow time problem. Kellerer et al. (1999) present a O(n12 )-

approximation algorithm for the 1|rj |∑wjFj problem onn jobs and prove that unless P = N P , there cannot beany approximation algorithm running in polynomial timefor this problem with a worst-case performance guarantee

of O(n12 −ε) for any ε > 0. Researchers have been focus-

ing on heuristic or branch-and-bound algorithms to studythis problem (Chu 1992a, 1992b; Dyer and Wolsey 1990;Hariri and Potts 1983).

Batching adds another dimension of difficulty for allthese scheduling problems. Hall and Potts (2003) show thatthe batching version of these scheduling problems is at leastas hard as the ones without batching. Thus, for example,even the sum of completion times problem, 1|rj |∑Cj +nd, is strongly N P -hard. Even fewer results are known forthe sum of flow times objective, which is known to be hardto approximate. Gfeller et al. (2009) study single machineonline batch scheduling with release times, setup times butno deliveries. They present a 2-competitive algorithm for theproblem when all jobs have equal processing times. Whenprocessing times are arbitrary, they prove the competitiveratio N in the worst case for a problem with N jobs. Leeand Yoon (2010) present heuristic algorithms for scheduling

batch deliveries with limited batch size and two types of in-ventory cost. They also give N P -hardness proofs for somerestricted cases and polynomial time solutions for other spe-cial cases. Mazdeh et al. (2008) present a branch and boundalgorithm for a special case of the 1|rj |∑Fj + nd prob-lem when pi < pj implies ri < rj for every pair of jobs.In this paper we consider the general 1|rj |∑wjFj + nd

problem and several special cases. We develop a polyno-mial time algorithm for 1|rj ,pmtn|∑wFj + nd and theequivalent 1|rj ,pmtn|∑wCj + nd problem when the jobshave the common weight w. Based on this, we obtain a 2-approximation algorithm for 1|rj |∑wCj +nd. Finally, wepresent an evolutionary metaheuristic algorithm and an eas-ily obtainable good lower bound for 1|rj |∑wjFj + nd .Computational experiments with this metaheuristic showthat the average gap between the best solutions and the lowerbound is not greater than 2.5%.

The paper is organized as follows: Sect. 2 discusses theproblem definition and some preliminaries. In Sect. 3, wegive a fast batching algorithm for any fixed job sequence.In the next section, we study the special case of the prob-lem where jobs have identical weights. A metaheuristic al-gorithm and a lower bound are developed in Sect. 5 for theproblem 1|rj |∑wjCj + nd . This is followed by reportingour computational experiments and Sect. 6 contains our con-clusions and some topics for future research.

2 Problem definition and some preliminaries

We define our problem as follows: There are N jobsJ1, J2, . . . , JN to be scheduled on a single machine. Wedenote by pj, rj and wj the processing time, the releasetime and the nonnegative weight, respectively, of job Jj , forj = 1,2, . . . ,N . Jobs are to be delivered in n batches atthe time of completion for the last job in the batch (batchavailability), where n is to be determined, and associatedwith each batch is a fixed batch-delivery cost d . Because ofthe batch availability assumption, the batch-completion timeCj of a job Jj delivered in batch θk (k ≤ n) is defined as thecompletion time of the last job processed in that batch, i.e., itequals the completion time of the batch. The flow time of jobJj is defined by Fj = Cj − rj using the batch-completiontime. Our goal is to find a schedule which minimizes thesum of the weighted flow times and the batch-delivery costs.We denote this problem by 1|rj |∑wjFj + nd . We assumew.l.o.g. that all the data are nonnegative integers. The fol-lowing easy-to-prove proposition states that there is an op-timal schedule which does not contain avoidable deliverydelays.

Proposition 1 Let cj denote the time when job Jj com-pletes its processing on the machine for j = 1,2, . . . ,N.

J Sched (2013) 16:69–79 71

Then there exists an optimal schedule in which job Jj is de-livered in the first batch delivered after time cj .

Consider a given fixed job sequence σ = J1, J2, . . . , JN .We can assume w.l.o.g. that if any job Ji (i > 1) starts itsprocessing in σ strictly after ci−1, then ri > ci−1. When thishappens, we call ti = ri − ci−1 the forced idle time. We de-fine the modified problem on σ, by replacing in it the pro-cessing time of job Ji by p′

i = pi + ti for i = 1,2, . . . ,N,

where t1 = 0 always. Now we show that the solution of themodified batching problem on σ is equivalent to solving theoriginal batching problem on σ .

Lemma 1 For a given job sequence, the modified batch-scheduling problem is equivalent to the original batch-scheduling problem.

Proof Consider an n-batching schedule with batches θ1, θ2,

. . . , θn on the given fixed job sequence σ = J1, J2, . . . , JN .Let TC∗(σ ) and TC∗

mod(σ ) be, respectively, the sum of theweighted flow times in the batch schedule σ with the origi-nal data and for the modified problem. Then

TC∗(σ ) =∑

i∈θ1

wi

[∑

j∈θ1

(pj + tj ) − ri

]

+∑

i∈θ2

wi

[∑

j∈(θ1∪θ2)

(pj + tj ) − ri

]

+ · · · +∑

i∈θn

wi

[N∑

j=1

(pj + tj ) − ri

]

+ nd

=∑

i∈θ1

wi

∑

j∈θ1

(pj + tj ) +∑

i∈θ2

wi

∑

j∈(θ1∪θ2)

(pj + tj )

+ · · · +∑

i∈θn

wi

N∑

j=1

(pj + tj ) −N∑

i=1

wiri + n

=∑

i∈θ1

wi

∑

i∈θ1

p′i +

∑

i∈θ2

wi

∑

i∈(θ1∪θ2)

p′i

+ · · · +∑

i∈θn

wi

N∑

i=1

p′i −

N∑

i=1

wiri + nd

= TC∗mod(σ ). �

For a given job sequence, the modified processing timecan be obtained in O(N) time by setting p′

i = pi +max{0, ri −ci−1}, where ci−1 is the completion time of Ji−1,and c0 = 0.

Remark 1 Let TC′mod(σ ) be the sum of weighted comple-

tion times for the sequence σ using the modified processing

times and no release times. Then TCmod(σ ) = TC′mod(σ ) −

∑Ni=1 wiri , and thus it is clear that minimizing TC′

mod(σ ) isequivalent to minimizing TCmod(σ ) because

∑Ni=1 wiri is a

constant.

Thus we have the following Lemma:

Lemma 2 The modified batch-scheduling problem on agiven sequence is equivalent to finding the optimal batchingof the same sequence of jobs with the modified processingtimes and without release times that minimizes the sum ofweighted completion times and delivery costs.

3 Optimal batching of a fixed job sequence

Next we show that batch scheduling of a given job se-quence without release times can be solved polynomiallyby an extension of the algorithm of Coffman et al. (1990)with some modifications, similar to the ones used by Al-bers and Brucker (1993). We follow the notation of Al-bers and Brucker. A batching solution on the job sequenceJ1, J2, . . . , JN with k batches can be written in the form

BS = {Ji1, . . . , Ji2−1}, {Ji2, . . . , Ji3−1}, . . . ,{Jik−1, . . . , Jik−1}, {Jik , . . . , JN },

where ij is the index of the first job in the j th batch and1 = i1 < i2 < · · · < ik ≤ N . We show that this problem canbe reduced to the special shortest path problem discussedby Albers and Brucker. Let F(BS) be the total cost (sum ofthe weighted flow time and the delivery cost) of the batch-ing solution BS. Since the completion time of every item in

batch {Jij , Jij +1, . . . , Jij+1−1} is∑ij+1−1

v=i1pv, F (BS) can be

calculated as follows:

F(BS) =k∑

j=1

[(N∑

v=ij

wv

)(ij+1−1∑

v=ij

pv

)

+d

]

,

where ik+1 = N + 1 is a ‘dummy’ job. If we set

ci,j =(

N∑

v=i

wv

)(j−1∑

v=i

pv

)

+d,

which is the cost contribution by the batch containing jobsJi, Ji+1, . . . , Jj−1, then F(BS) = ∑k

j=1 cij ,ij+1 . Further-

more, for any k > j , cik − cij = (∑N

v=i wv)(∑k−1

v=j pv) =f (i)h(j, k), where f (i) = ∑N

v=i wv and h(j, k)=∑k−1v=j pv.

Since f (i) is monotone nonincreasing and h(j, k) ≥ 0 forall j < k, our problem can also be formulated as a specialshortest path problem in a network similar to the one intro-duced by Albers and Brucker. The following is the corre-sponding network for our problem.

72 J Sched (2013) 16:69–79

a. Each job Ji (i = 1,2, . . . ,N ) is represented by a vertex i

in the network.b. Since the job sequence J1, J2, . . . , JN is given, the net-

work contains edges (i, j) only if i < j .c. Any edge (i, j) is assigned an edge length cij .d. A dummy job JN+1 with pN+1 = wN+1 = 0 is added.

The batching problem then is equivalent to finding theshortest path from vertex 1 to vertex N + 1 in the network.Let Fj be the length of the shortest path from vertex j tovertex N + 1, and Fj (k) be the length of a shortest pathfrom j to N + 1 which contains (j, k) as first edge. Then,Fj (k) = cjk + Fk , and Fj = min{Fj (k)|j < k ≤ N + 1}.Therefore, Fj (k) ≤ Fj (l) for vertices j < k < l is equiv-alent to Fj (k) − Fj (l) = cjk + Fk − cjl − Fl ≤ 0. Butcjl − cjk = f (j)h(k, l), therefore the condition can be writ-ten as f (j) ≥ Fk−Fl

h(k,l). Thus for any two vertices k, l (k < l),

if the threshold δ(k, l) = Fk−Fl

h(k,l)≤ f (j), then Fj (k) ≤ Fj (l).

On the other hand, if f (j) < δ(k, l), then Fj (k) > Fj (l).Therefore, the problem can be solved in O(N) time usinga slightly modified version of the algorithm by Albers andBrucker. They use the queue data structure shown in Fig. 1to solve the problem.

Algorithm A1 (Modified algorithm of Albers and Brucker)beginStep 1 Set q = N + 1 and FN+1 = 0.Step 2 for j = N to 1, do the following:Step 2.1 If head(q) �= tail(q) and f (j) ≥

δ(next(head(q)),head(q)), delete head(q)

from q;Step 2.2 Set N(j) = head(q) and Fj = cj,N(j) +

FN(j);Step 2.3 If head(q) �= tail(q) and δ(j, tail(q)) ≤

δ(tail(q),previous(tail(q))), delete tail(q)

from q;Step 2.4 Add j to the tail of q.

endforend

The correctness of the algorithm is based on the follow-ing two lemmas, which can be proved by the same proof asin Albers and Brucker (1993).

Lemma 3 Let 1 ≤ j < k < l be vertices satisfying f (j) ≥δ(k, l). Then Fi(k) ≤ Fi(l), for all i = 1,2, . . . , j .

Lemma 4 Suppose δ(j, k) ≤ δ(k, l) for some vertices 1 ≤j < k < l ≤ n + 1. Then for each vertex i, 1 ≤ i ≤ j , eitherFi(j) ≤ Fi(k) or Fi(l) < Fi(k).

In order to obtain the linear time complexity, we needto do some preprocessing. The f (j) values can easily becomputed in a preprocessing step in O(N) time. To make

an h(j, k) value computable in O(1) time, we also computein the preprocessing step the following:

sp(i) ={

0, for i = 1,∑i−1

v=1 pv, for i = 2,3, . . . ,N + 1.

This clearly requires O(N) time and using h(j, k) =sp(k) − sp(j) makes any h(j, k) computable in O(1) time.Once we have these values, then each cij and cik − cij valueneeded can be calculated in O(1) time. Finally, the algo-rithm requires at most O(N) iterations, as each vertex getsadded or deleted at most once from q . Thus we have thefollowing lemma.

Lemma 5 Algorithm A1 finds an optimal batching of agiven job sequence without release times in O(N) time.

Now we provide our optimal batching algorithm for thefixed job sequence problem:

Algorithm A2 (Batching algorithm for jobs with fixed se-quence)beginStep 1 Input job sequence and other data.Step 2 Compute the modified processing time for all the

jobs.Step 3 Call Algorithm A1 to solve the modified problem.end

Corollary 1 Algorithm A2 finds the minimum cost batchingof a fixed job sequence for the 1|rj |∑wjFj + nd problemin O(N) time.

Proof For any given job sequence, we can find the equiva-lent modified batching problem in O(N) time. The optimalbatching of the job sequence for this modified problem canbe found in O(N) time. �

The corollary implies that if the optimal job sequence canbe found in polynomial time then the 1|rj |∑wjFj + nd

batch-scheduling problem can also be solved in polynomialtime. It is easy to see that if the job processing times and theweights are identical for every job, i.e., pj = p and wj = w

for j = 1, . . . ,N, then ordering the jobs in non-decreasingorder of the release times yields an optimal sequence. Thuswe have the following corollary.

Corollary 2 The 1|rj ,pj = p|∑wFj +nd batch-schedul-ing problem can be solved in O(N) time.

4 Jobs with identical weight

In this section, we study batch scheduling of jobs with ar-bitrary release times and processing times but with identical

J Sched (2013) 16:69–79 73

Fig. 1 Structure of a queue q

� � � � � �tail next(i) i previous(i) head

weights. We first show that when preemption is allowed, theproblem is not NP-hard, i.e., the 1|rj ,pmtn|∑wFj + nd

problem is polynomially solvable. Using this solution, wedevelop a 2-approximation algorithm for the 1|rj |∑wCj +nd problem.

4.1 Preemptive version of the special case

When preemption is allowed, processing of a job can be in-terrupted and the remaining part is continued at a later time.However, the job can be delivered only after the whole job iscompleted. A part of job Jj will also be called a fractionaljob Jj . Let λJj (0 < λ ≤ 1 and j = 1,2, . . . ,N ) represent λ

fraction of job Jj with processing time λpj .

Lemma 6 There exists an optimal schedule for the 1|rj ,pmtn|∑wFj + nd problem in which whenever a job iscompleted or a new job arrives, the available job withthe shortest-remaining processing time (SRPT) is schedulednext.

Proof Suppose the lemma does not hold, and consider anoptimal schedule as shown in Fig. 2(a), in which the earli-est violation of the SRPT rule occurs at some time t , i.e.,two fractional jobs βJi and αJj are available for process-ing with βpi < αpj , 0 < α ≤ 1 and 0 < β ≤ 1, and theoptimal schedule first schedules a part of αJj , say α′Jj ,where 0 < α′ ≤ α. Let us assume that βJi is split into r

fractional jobs βkJi (k = 1,2, . . . , r) in the schedule. LetβkJi start processing at time tik , where k = 1,2, . . . , r andti1 ≤ ti2 ≤ · · · ≤ tir , and complete at time cik in this opti-mal preemptive schedule. Also assume that αJj completesprocessing at cj .

Exchange the whole or part of α′Jj and a correspondingwhole or part of β1Ji of exactly the same size in the sched-ule. More precisely, take min(α′pj ,β1pi) part from the be-ginning of α′Jj and the same amount of processing fromthe beginning of β1Ji and exchange them in the schedule.We can have two cases:

1. If min(α′pj ,β1pi) = α′pj , then this violation of theSRPT rule is removed in the resulting schedule (refer toFig. 2(b) where β ′

1pi = α′pj and β ′′1 pi = β1pi − α′pj ).

In this case find the next violation (if any) of the SRPTrule between jobs Jj and Ji occurring at some time t ′ > t

and exchange the first parts of the jobs in a similar fash-ion.

2. If min(α′pj ,β1pi) = β1pi = α′1pj < α′pj , then the sit-

uation is depicted in Fig. 3. (Note that a second, separate

piece α′′Jj is used to represent the last part of job αJj inthe original schedule.) The exchange results in a schedulein which the next violation (if any, which can occur onlywhen r > 1) of the SRPT rule between jobs Jj and Ji

will be at t ′ = t + β1pi. In this case, repeat the exchangebetween the corresponding remaining (α′

2 = α′ − β1pi

pj)

part of Jj and β2Ji.

Since βpi < αpj , it can be seen that the repeated appli-cation of this exchange argument eventually will result in aschedule in which all parts βkJi (k = 1,2, . . . , r) are sched-uled before all parts of αJj . Let c′

i and c′j be the completion

times of βJi and αJj , respectively, in this new schedule af-ter all the exchanges have been performed between thesetwo jobs. We clearly have c′

i ≤ cir . It is also easy to seethat (the last part of) βJi will be finished in the resultingschedule no later than the original completion time cj ofαJj , i.e., c′

i ≤ cj . Furthermore, all parts of αJj which wereexchanged with parts of βJi will be finished by cir . If weoriginally had cir < cj , then the exchanges do not delay thecompletion time of αJj , i.e., c′

j = cj . Otherwise, we havec′j = cir . In either case, since the completion times of other

jobs clearly do not change after the transformation, at leastthe same number of jobs will be available for delivery bycir and cj (and by any other given time) in the resultingschedule. Thus, if we assign the same number of jobs (inthe order of their completion times in the new schedule) toeach batch, none of the batch-delivery times can increase incomparison to the original schedule. Note that the numberof batches also stays the same, and thus the total cost of theresulting schedule is not greater than that of the original op-timal schedule.

Finally, we observe that repeated applications of theabove exchange argument (between all violating pairs ofjobs) will clearly end with a schedule which has no viola-tion of the SRPT rule left and is also optimal. �

Without loss of generality, let the completion times ofthe jobs in the SRPT preemptive schedule be c1 < c2 <

· · · < cN. Consider any batching of the SRPT preemptiveschedule into n batches θ1, θ2, . . . , θn with batch-completiontimes t1 < t2 < · · · < tn. Each θi contains those jobs whichhave their last fractional part finished in the interval (ti−1, ti]for i = 1,2, . . . , n with t0 = 0. Consider a new problem onN jobs J ′

1, J′2, . . . , J

′N with weight w, release times r ′

j = 0and processing times p′

j = cj − cj−1, for j = 1,2, . . . ,N ,where c0 = 0. Let the given job sequence of these jobs

74 J Sched (2013) 16:69–79

Fig. 2 Schedules for Lemma 6with min{α′pj ,β1pi} = α′pj

� � � � � � � � �α′Jj β1Ji β2Ji βr Ji

t ci1 ci2 cirti1 ti2 tir

(a) Before exchanging α′Jj and β1Ji

� � � � � � � � �β′1Ji α′Jj β′′

1 Ji β2Ji βr Ji

t ci1 ci2 cirti1 ti2 tir

(b) After exchanging α′Jj and β1Ji

Fig. 3 Schedules for Lemma 6with min{α′pj ,β1pi} = β1pi

� � � � � � � � �α′Jj β1Ji α′′Jj βr Ji

t ci1 cj cirti1 tir

(a) Before exchanging α′Jj and β1Ji

� � � � � � � � �β1Ji α′2Jj α′

1Jj α′′Jj βr Ji

t t ′ ci1 cj cirti1 tir

(b) After exchanging α′Jj and β1Ji

be σ ′ = J ′1, J

′2, . . . , J

′N. It is easy to see that the SRPT

preemptive schedule on the original job set and the non-preemptive schedule σ ′ on the jobs J ′

1, J′2, . . . , J

′N will have

the same number of jobs finished by any of the timesti , i = 1,2, . . . , n. Thus the batching θ1, θ2, . . . , θn also in-duces a batching of σ ′ with batch-completion times t1 <

t2 < · · · < tn and each induced batch contains the same num-ber of jobs as the corresponding θi . This means that everyjob j ∈ θi with batch-completion time Cj will have a cor-responding job J ′

j in the induced batching schedule withbatch-completion time C′

j = Cj . Therefore, for the total cost

of the two schedules we will have TC = w∑N

j=1Cj + nd =w

∑Nj=1C

′j +nd = TC′. Thus we have proved the following.

Lemma 7 There is a one-to-one correspondence betweenthe optimal batching schedule for the fixed sequence σ ′ =J ′

1, J′2, . . . , J

′N with objective w

∑Nj=1C

′j + nd and the opti-

mal SRPT batching schedule for 1|rj , pmtn|∑Nj=1wCj +nd

on job set {J1, J2, . . . , JN }.

Now we are ready to give our optimal batch-schedulingalgorithm for the 1|rj ,pmtn|∑wCj + nd problem and the1|rj ,pmtn|∑wFj + nd problem.

Algorithm A3 (Algorithm for optimal preemptive batchscheduling for jobs with identical weight)beginStep 1 Find the SRPT job sequence.Step 2 Based on the SRPT sequence, generate the data

for J ′1, J

′2, . . . , J

′N and the job sequence σ ′.

Step 3 Call Algorithm A2 for σ ′ to obtain the optimalbatching of σ ′ and the corresponding optimalbatching of the SRPT schedule.

end

Theorem 1 Algorithm A3 finds an optimal schedule for the1|rj ,pmtn|∑wCj +nd and 1|rj ,pmtn|∑wFj +nd prob-lems in O(N logN) time.

Proof Based on Lemma 7, Algorithm A3 finds an optimalschedule for 1|rj ,pmtn|∑wCj + nd. Furthermore, sincefor any batching of the SRPT preemptive schedule the differ-ence in the cost functions between the

∑Nj=1wCj + nd and

∑Nj=1wFj + nd = ∑N

j=1w(Cj − rj ) + nd objectives is the

constant∑N

j=1wrj , the optimal batching schedules for the

1|rj , pmtn|∑Nj=1wCj +nd and 1|rj , pmtn|∑N

j=1wFj +nd

problems are the same. Thus Algorithm A3 also solves the1|rj , pmtn|∑N

j=1wFj + nd problem.Step 1 requires sorting the jobs into non-decreasing order

of their release times, and therefore it runs in O(N logN)

time. Step 2 can be implemented in O(N) time. Step 3 runsin O(N) time by Lemma 5. Thus the overall run time isO(N logN). �

Remark 2 Preemption occurs in the SRPT schedule onlywhen a new job arrives and its processing time is less thanthe remaining time of the current processed job. Thus theprocessing of any job in the schedule can start only at itsrelease time or when another job is completed. This impliesthat there can be at most 2N − 1 start times in the optimalpreemptive schedule.

4.2 Non-preemptive version of the special case

In an optimal preemptive batch schedule, the lth deliverybatch θl (l = 1,2, . . . , n), which is delivered at time Dl ,may contain two types of job: (i) set of jobs which are com-pletely processed in the time interval (Dl−1,Dl], we denotethis set by COl , and (ii) set of jobs for which only a frac-tion of the job is processed in (Dl−1,Dl], we denote this

J Sched (2013) 16:69–79 75

set by FRl . Therefore, θl = COl ∪ FRl . Note that for eachjob in FRl , the corresponding remaining parts are processedbefore Dl−1. Also note that even though jobs in COl areprocessed in whole in (Dl−1,Dl], some of them may be pro-cessed in pieces (preempted) in (Dl−1,Dl]. We call all thesepieces which are processed before (separately from) the lastpiece of each job in θl the early parts of θl and let ul bethe total time required to process these early parts. Clearly,∑l

j=1 uj < Dl .

Lemma 8 Consider a batch θl . Starting from the beginningof the preemptive schedule, shift every early part of everyJi ∈ θl to start its processing immediately before the lastpiece of Ji . This may delay the completion time of everyjob in

⋃nj=l θj . Let l denote the change in the sum of

the weighted batch-completion times. Then we have l ≤ul

∑nj=l w|θj |.

Proof Moving the early parts of all jobs Ji ∈ θl to imme-diately before their last piece will not increase the deliverytimes of batches θ1, θ2, . . . , θl−1. However, it may increasethe delivery times of batches θl, θl+1, . . . , θn by at most ul

time units. Therefore, l ≤ ul

∑nj=l w|θj |. �

Lemma 9 Perform the right shifts of early parts describedin Lemma 8 for all the jobs in batches θl in the or-der l = 1,2, . . . , n. Let = ∑n

l=1 l be the change inthe total cost

∑Nj=1wCj + nd . Then < TC∗

pmt, whereTC∗

pmt denotes the cost of the optimal batching schedule for1|rj ,pmtn|∑wCj + nd.

Proof It is clear that performing all the right shifts, we ob-tain a non-preemptive schedule for the 1|rj |∑wCj + nd

problem. Furthermore,

=n∑

l=1

l ≤n∑

l=1

(

u

l

n∑

j=l

w|θj |)

= u1w(|θ1| + |θ2|

+ · · · + |θn|) + u2w(|θ2| + |θ3| + · · · + |θn|

)

+ · · · + unw(|θn|

)

= u1w|θ1| + (u1 + u2)w|θ2|+ · · · + (u1 + u2 + · · · + un)w|θn|.

But∑i

j=1 uj < Di , for i = 1,2, . . . , n. Therefore,

< D1w|θ1| + D2w|θ2| + · · ·

+ Dnw|θn| <n∑

i=1

w|θi |Di + nd = TC∗pmt. �

Thus we can develop a non-preemptive batch scheduleto approximate the optimum. When we move all the early

parts of θl (l = 1,2, . . . , n) as described in the above lemma,we obtain a non-preemptive schedule, in which jobs are se-quenced according to their completion times in the SRPTschedule. This schedule can be obtained in O(N) time fromthe optimal schedule for 1|rj ,pmtn|∑wCj + nd . We sum-marize our approximation algorithm below.

Algorithm A4 (Approximation algorithm for schedulingnon-preemptive, equal-weight jobs)beginStep 1 Find the SRPT job sequence.Step 2 Schedule jobs in the order of their completion

time in the optimal preemptive (SRPT) sched-ule.

Step 3 Call Algorithm A2 for the optimal batching ofthis sequence.

end

Theorem 2 Algorithm A4 is a 2-approximation algo-rithm for the 1|rj |∑wCj + nd problem and it requiresO(N logN) time.

Proof The total cost of moving all the early parts in θl (forl = 1,2, . . . , n) in the optimal preemptive batch-deliveryschedule is less than TC∗

pmt by Lemma 9. Therefore, theresulting schedule will have a cost at most 2TC∗

pmt. Wealso know that the jobs of this non-preemptive batch sched-ule follow the order of their completion in the optimalpreemptive schedule. Therefore any optimal batch-deliveryschedule on this sequence will not have a cost higher than2TC∗

pmt. Algorithm A2 finds the optimal batching of thisjob sequence. TC∗

pmt is clearly a lower bound for the min-imum cost of the 1|rj |∑wCj + nd problem. Hence Al-gorithm A4 is a 2-approximation algorithm for the non-preemptive problem. It is also clear from the earlier discus-sion that each step of the algorithm can be implemented inO(N) or O(N logN) time. �

5 The general weighted case

In this section, we develop a metaheuristic algorithm tosolve the 1|rj |∑wjFj + nd problem. We use a genetic al-gorithm to obtain different job sequences. Algorithm A2 isused then to find the optimal batching of any given job se-quence. We call Algorithm A2 for each generated job se-quence and set as the fitness value the sum of the totalweighted flow time and the batch-delivery cost for the op-timal batching of the job sequence. In order to evaluate theperformance of the metaheuristic algorithm, we establish alower bound for the problem by solving an auxiliary unit-processing-time (UPT) problem.

76 J Sched (2013) 16:69–79

5.1 Metaheuristic algorithm

In early applications of genetic algorithms in scheduling, theprimary strategy used for encoding sequences was the lit-eral permutation order. In permutation order encoding, eachchromosome represents the job order in the correspondingschedule. For example, in a permutation order encoding sys-tem, a job sequence {3,2,5,1,4} is encoded as given belowin the left figure. Whenever a crossover or mutation oper-ation is carried out, the feasibility of the schedule is notguaranteed by this encoding system. Thus, using permuta-tion order encoding forces the algorithm developer to applyspecialized operators in the crossover procedure in order tomaintain the feasibility. To avoid this difficulty, we use therandom keys encoding by Bean (1994).

3 2 5 1 4 0.345 0.983 0.726 0.167 0.529

Random key genetic algorithm (RKGA) is widely used inapplications for scheduling problems because it only pro-duces feasible offsprings. Moreover, relative and absoluteordering information can be preserved after recombinationof parents. In RKGA a chromosome is assigned a string ofrandom numbers. For example, consider the chromosomein the right figure above. The interpretation of this chromo-some is as follows: Jobs J1, J2, . . . , J5 are assigned randomnumbers 0.345, 0.983, 0.726, 0.167 and 0.529, respectively.Then the job sequence of this chromosome is obtained byordering the jobs in ascending order of their random num-bers. Therefore, the job sequence of this chromosome is{4,1,5,3,2}.

We briefly describe the main features of our metaheuris-tic below. Most of the control parameter values were deter-mined after extensive computational experiments identify-ing the values that seem to have worked best within reason-able execution time. (We include some comments about thefine tuning of the parameters in the appropriate part.)

Population Sequence We use a population size of 30 in ouralgorithm. Initially, each sequence contains the jobs in ran-dom order. For each job, a random number in (0,1) (thekey) is generated and assigned to it. We decode each chro-mosome and obtain the sequence. Three special sequences(SPT, WSPT and LW, i.e., largest weight first) are addedlater, when no improvements in the solution occur after acertain number of iterations.

Fitness Value Calculation We call Algorithm A2 to obtainthe optimal batching solution for any given job sequence.Then we calculate the total cost of the batching solution andset it as the fitness value.

Parent Selection The population is ordered randomly. Weuse the roulette wheel method to select two parents to createtwo new offsprings by two randomly generated numbers in(0,1). In roulette wheel selection, the probability of select-ing a parent is set to the ratio of the parent’s fitness value tothe total fitness value of the population.

Crossover We use two-point crossover with a crossoverprobability of 0.8. Suppose there are six jobs in the problemand the following two figures are the chromosomes, whichcan be interpreted as two sequences.

0.359 0.278 0.599 0.801 0.745 0.429

0.159 0.878 0.726 0.167 0.352 0.589

We randomly generate two position numbers. Suppose theseare 2 and 4. Then we exchange the keys in the first twocorresponding positions of the above two chromosomes andthe keys in the corresponding positions beyond position 4 inthe above two figures, respectively, but keep the keys in theremaining middle positions of the above figures the same.Thus, we obtain the following two chromosomes.

0.159 0.878 0.599 0.801 0.352 0.589

0.359 0.278 0.726 0.167 0.745 0.429

For sequences with large chromosomes (large N ), two-pointcrossover mixes the genes sufficiently to generate a wide va-riety. The 0.8 crossover probability was determined to be thebest after experimenting with other values from [0.7,0.9].Mutation For each chromosome obtained after crossover,we select two distinct randomly chosen numbers k, i ∈{1, . . . ,N}. Then we exchange the genes (jobs) of that chro-mosome with a probability of 0.2, which was determined tobe the most effective after trying values from [0.1,0.3].Population Pool The new generated child will be acceptedonly when its fitness value is different from that of the previ-ously accepted children or the current population. The sizeof the pool is 120, which includes 90 new ones and the cur-rent 30. (We have also tried values of 90 and 60 for the sizeof the pool and the number of new children, respectively,but the higher values improved the algorithm’s performanceat relatively small cost.) When for more than 100 iterationsthe best solution is not changed, we give a random shake tothe population pool by introducing a new chromosome cor-responding to a random selection of one of the SPT, WSPTor LW orders.

Population Selection The pool is ordered in non-decreas-ing order of the fitness values. Part of the new populationwill be selected from the best 30 of the pool randomly, andthe remaining part of the new population will be randomlyselected from the last 90 of the pool.

J Sched (2013) 16:69–79 77

Stopping Criterion The metaheuristic will stop when thenumber of iterations reaches its maximum, say 2000, or thebest fitness value cannot be improved after 200 iterations.The solution finally returned by the metaheuristic algorithmis the one with the best fitness value obtained.

The metaheuristic algorithm is summarized as follows.

Algorithm A5 (Metaheuristic algorithm for the generalproblem)beginStep 1 Data generation and initialization.Step 2 Generate a population (job sequences) of

size 30.Step 3 Check the stopping criterion: If satisfied, then

stop; otherwise, go to Step 4.Step 4 Do reproduction for selected pairs of parents:Step 4.1 Do crossover with probability 0.8 and mu-

tation with probability 0.2;Step 4.2 If the child is not already in the population

pool, add the child to the pool.Step 5 Select a new population of size 30 from the

pool and calculate the fitness values.Step 6 If the best value has not changed for 100 it-

erations, do a random shake, calculate the fit-ness values and go to Step 3; Otherwise, go toStep 4.

end

5.2 Lower bound

We replace each job Ji (i = 1,2, . . . ,N ) with pi UPT jobs,i.e., J ′

k with processing time p′k = 1, weight w′

k = wi

piand

release time r ′k = ri (for k = ∑i−1

j=1 pj + 1,∑i−1

j=1 pj +2, . . . ,

∑ij=1 pj ). It is clear that any batch schedule for

the original problem can be interpreted as a schedule withthe same cost for these UPT jobs, in which UPT jobs de-rived from the same “parent” job are scheduled contigu-ously. Therefore, if we relax this contiguity requirement andfind the optimal batch schedule of these UPT jobs, the totalcost of this optimal batch-delivery schedule will be a lowerbound for our problem. In the next section, we briefly dis-cuss the optimal batching of UPT jobs.

If we could find the optimal job sequence for the UPTjobs then Algorithm A2 will find the optimal batching forthat sequence. In Lemma 10, we prove that the Ready LWjob sequence is optimal for the UPT problem. Ready LW isa schedule in which at each job arrival and/or completion,a job with the largest weight among the available jobs isscheduled next.

Lemma 10 The Ready LW schedule minimizes the total costof UPT jobs.

Proof Let us assume that the lemma does not hold. Thenthere exists an optimal schedule in which jobs J ′

j and J ′i

are both available at time t1, J ′j is scheduled at time t1 and

J ′i at t2, where t2 > t1 and w′

i > w′j . Let t2 − (t1 + 1) = T

(refer to Fig. 4) and the total weight of all the jobs scheduledin the time interval (t1 + 1, t2) be W .

Let us exchange jobs J ′i and J ′

j while not affecting thebatch-delivery times and let the change in the total cost be. Since J ′

i and J ′j are UPT jobs, the exchange will not

change the completion time of any other job. If J ′i and J ′

j

were delivered in different batches in the optimal schedule,then

≤ w′j (T + 1) − w′

i (T + 1)

= (T + 1)(w′

j − w′i

)< 0,

which contradicts the optimality assumption. Thus J ′i and

J ′j must have been delivered in the same batch in the opti-

mal schedule. In this case, however, we can clearly exchangethem so that = 0. Repeating this argument for every pairviolating the Ready LW rule, will eventually yield an opti-mal schedule with no violation left. �

Since we know the optimal job sequence for the batchingproblem, using Algorithm A2, we can obtain the optimalbatching of this job sequence. Now we describe the majorsteps of our algorithm to find the lower bound.

Algorithm A6 (Algorithm to compute the lower bound forthe general problem)beginStep 1 Construct the associated UPT problem.Step 2 Schedule the UPT jobs in Ready LW order.Step 3 Call Algorithm A2 to find the optimal batching

of the Ready LW schedule.end

Lemma 11 Algorithm A6 solves the 1|rj ,UPT |∑wjFj +nd problem in O(N logN + ∑

pj ) time.

Proof The correctness of the algorithm follows from theprevious discussion. For its complexity, we note that therewill be

∑pj UPT jobs constructed. The O(N logN) term

is required by Step 2. �

5.3 Computational experiments

In order to analyze the performance of our metaheuris-tic algorithm, we coded the metaheuristic algorithm andthe lower bound algorithm in Dev-C++ version 4.9.9.2 andtested it on a HP ProLiant DL785 G5 server with an 8times Quad-Core AMD Opteron Processor 8356, running at

78 J Sched (2013) 16:69–79

Fig. 4 Schedule for Lemma 10

� � � � � � � � �J ′j J ′

i

�� (W,T )

t1 t2

Table 1 Performance of Algorithm A5 for wi = U(1,100), pi = U(1,100)

Type of instance d = 500 d = 1000 d = 1500

% Gap % Gap % Gap

Avg. Max. Avg. Max. Avg. Max.

R = 1 2.4703 3.2378 1.9654 2.8189 1.9417 2.7603

R = 2 2.1116 2.5634 1.6671 2.3899 1.4577 2.1561

R = 3 2.4528 2.9305 2.1835 3.6092 1.9500 2.4010

R = 4 2.0431 2.6341 1.7419 2.2208 1.6101 2.2219

R = 5 1.6128 2.1537 1.3553 1.7529 1.2359 1.5633

R = 10 0.4499 0.5798 0.3155 0.4703 0.2583 0.4048

Table 2 Performance of Algorithm A5 for wi = U(1,10), pi = U(1,100)

Type of instance d = 500 d = 1000 d = 1500

% Gap % Gap % Gap

Avg. Max. Avg. Max. Avg. Max.

R = 1 1.5201 2.4239 1.1744 2.1331 1.3117 2.4436

R = 2 1.6867 2.3228 1.4570 2.1074 1.3946 2.1380

R = 3 1.6805 2.0521 1.5739 2.1245 1.5285 1.9373

R = 4 1.4161 2.4470 1.2566 1.9996 1.2089 1.5732

R = 5 1.0375 1.5899 0.9553 1.6487 0.8589 1.4081

R = 10 0.2091 0.3509 0.1728 0.3027 0.1493 0.2660

2.3 GHz with 512 KB of cache. The results of our experi-

ments are summarized in Tables 1 and 2. We tested the algo-

rithm for problems with 50 jobs and processing times ran-

domly generated from U(1,100) (discrete uniform distribu-

tion). Since our problem is what Hall and Potts (2003) called

the “Manufacturer’s problem” in supply chain scheduling,

we follow that model and have the jobs arrive in batches

at different time points. Arrival batch sizes are randomly

generated from U(1,5) and arrival times (release times)

are from U(0,505 × R). We set six different values for

R = {1,2,3,4,5,10} and therefore, there are six instance

types. We ran the algorithm for ten randomly generated

problems for each instance type. We consider three different

delivery costs d ∈ {500,1000,1500} for each problem. For

instances in Table 1, weights are from U(1,100), whereas in

Table 2 weights are from U(1,10). The algorithm ran very

fast for all instances. The metaheuristic required between 15

secs and 30 secs per instance. The lower bound calculations

required 10 secs on average. Using these, we obtain the error

estimate

percentage gap = metaheuristic solution − lower bound

lower bound× 100.

The results of the experiments show that our algorithm isalways very close to the lower bound (and the optimum),as the maximum gap was less than 4%. The tables show thatin almost all the cases, the average percentage gap decreaseswith increasing batch-delivery cost. This may be because thelarger delivery cost results in larger batch sizes and job se-quence within a batch does not affect the total cost. Further-more, the results show that the average percentage gap in-creases when increasing R from 1 and then decreases whenR becomes larger. Thus the hardest instances for approxima-tion seem to occur for medium R values. Similar behaviorhas been observed for other scheduling problems with re-lease times too (Steiner and Stephenson 2000). A possibleexplanation for this phenomenon is that for small R val-ues, the release times tend to be early and thus have littleconstraining effect on the availability of jobs as the sched-

J Sched (2013) 16:69–79 79

ule progresses over time. Thus these problems tend to be-have for most of the schedule as problems without releasetimes, which makes their solution much easier. On the otherhand, when larger R values are used for generating the re-lease times, schedules tend to decompose into contiguousblocks of jobs separated by idle times. This partition is im-posed on the job set in all optimal schedules, which allowsmuch less variability in the scheduling sequences to be con-sidered. The problem essentially decomposes into a set ofmuch smaller independent subproblems.

6 Conclusions and future research

We have studied batch scheduling on a single machineto minimize the sum of weighted flow times and deliv-ery costs, 1|rj |∑wjFj + nd . We have proved that thepreemptive version of the problem with identical weights,1|rj ,pmtn|∑wFj + nd , can be solved polynomially andusing this, we developed a 2-approximation algorithm forthe 1|rj |∑wCj + nd problem. Furthermore, the algorithmcan also find optimal batching schedules for problems withidentical jobs. For the general case, we developed an evo-lutionary metaheuristic algorithm and an easily obtainablelower bound. Computational experiments show that the av-erage gap between the solution of the metaheuristic algo-rithm and the lower bound for the general case is under2.5%.

Hall and Potts (2003) presented a dynamic programmingalgorithm for the batch-scheduling problem with m > 1 cus-tomers, when job sequences for each customer are defined.Looking for heuristic or approximation algorithms for themultiple customer problem can be the subject of future re-search.

Acknowledgements The authors wish to thank an anonymous ref-eree, whose detailed comments led to a much better presentation forthe paper. This research was supported in part by Discovery Grants1798-03 and 341344-2008 by the Natural Sciences and EngineeringResearch Council of Canada.

References

Afrati, F., Bampis, E., Chekuri, C., Karger, D., Kenyon, C., Khanna,S., Milis, I., Queyranne, M., Skutella, M., Stein, C., & Sviridenko(1999). Approximation schemes for minimizing average weightedcompletion time with release dates. In Proc. 40th annual sympo-sium on foundations of computer science

Albers, S., & Brucker, P. (1993). The complexity of one-machinebatching problems. Discrete Applied Mathematics, 47, 87–107.

Allahverdi, A., Gupta, J. N. D., & Aldowaisan, T. (1999). A review ofscheduling research involving setup considerations. Omega, 27,219–239.

Allahverdi, A., Ng, C. T., Cheng, T. C. E., & Kovalyov, M. Y. (2008).A survey of scheduling problems with setup times or costs. Euro-pean Journal of Operational Research, 187, 985–1032.

Bean, J. C. (1994). Genetic algorithms and random keys for sequencingand optimization. ORSA Journal on Computing, 6, 154–160.

Chekuri, C., Motwani, R., Natarajan, B., & Stein, C. (2001). Approxi-mation techniques for average completion time scheduling. SIAMJournal on Computing, 31, 146–166.

Chu, C. (1992a). Efficient heuristics to minimize total flow time withrelease dates. Operations Research Letters, 12, 321–330.

Chu, C. (1992b). A branch-and-bound algorithm to minimize total flowtime with unequal release dates. Naval Research Logistics, 39,859–875.

Coffman, E. G., Yannakakis, M., Magazine, M. J., & Santos, C. (1990).Batch sizing and job sequencing on a single machine. Naval Re-search Logistics, 26, 135–147.

Dyer, M. E., & Wolsey, L. A. (1990). Formulating the single machinesequencing problem with release dates as a mixed integer pro-gram. Discrete Applied Mathematics, 26, 255–270.

Gfeller, B., Peeters, L., Weber, B., & Widmayer, P. (2009). Single ma-chine batch scheduling with release times. Journal of Combinato-rial Optimization, 17, 323–338.

Goemans, M. X., Wein, J. M., & Williamson, D. P. (2000).A 1.47-approximation algorithm for a preemptive single-machinescheduling problem. Operations Research Letters, 26, 149–154.

Graham, R. L., Lawler, E. L., Lenstra, J. K., & Rinnooy Kan, A. H.G. (1979). Optimization and approximation in deterministic se-quencing and scheduling: A survey. Annals of Discrete Mathe-matics, 4, 287–326.

Hall, N. G., & Potts, C. N. (2003). Supply chain scheduling: Batchingand delivery. Operations Research, 51, 566–584.

Hariri, A. M. A., & Potts, C. N. (1983). An algorithm for single ma-chine sequencing with release times to minimize total weightedcompletion time. Discrete Applied Mathematics, 5, 99–109.

Kellerer, H., Tautenhahn, T., & Woeginger, G. J. (1999). Approxima-bility and nonapproximability results for minimizing total flowtime on single machine. SIAM Journal on Computing, 28, 1155–1166.

Labetoulle, J., Lawler, E. L., Lenstra, J. K., & Rinnooy Kan, A. H. G.(1984). Preemptive scheduling of uniform machines subject to re-lease dates. In W. R. Pulleyblank (Ed.), Progress in combinatorialoptimization (pp. 245–261). New York: Academic Press.

Lee, I. S., & Yoon, S. H. (2010). Coordinated scheduling of productionand delivery stages with stage-dependent inventory holding costs.Omega, 38, 509–521.

Lenstra, J. K., Rinnooy Kan, A. H. G., & Brucker, P. (1977). Com-plexity of machine scheduling problems. Annals of OperationsResearch, 1, 343–362.

Mazdeh, M. M., Sarhadi, M., & Hindi, K. S. (2008). A branch-and-bound algorithm for single-machine scheduling with batch deliv-ery and job release times. Computers & Operations Research, 35,1099–1111.

Potts, C. N., & Kovalyov, Y. M. (2000). Scheduling with batching:a review. European Journal of Operational Research, 120, 228–249.

Schrage, L. (1968). A proof of the shortest remaining processing timeprocessing discipline. Operations Research, 16, 687–690.

Smith, W. E. (1956). Various optimizers for single-stage production.Naval Research Logistics, 3, 59–66.

Steiner, G., & Stephenson, P. (2000). Subset-restricted interchange fordynamic min-max scheduling problems. SIAM Journal on Dis-crete Mathematics, 13, 419–435.