Parallel-batch scheduling of deteriorating jobs with release dates to minimize the makespan

European Journal of Operational Research 210 (2011) 482–488

Contents lists available at ScienceDirect

European Journal of Operational Research journal homepage: www.elsevier.com/locate/ejor

Discrete Optimization

Parallel-batch scheduling of deteriorating jobs with release dates to minimize the makespan Shisheng Li a, C.T. Ng b,⇑, T.C.E. Cheng b, Jinjiang Yuan a a b

Department of Mathematics, Zhengzhou University, Zhengzhou, Henan 450001, People’s Republic of China Department of Logistics and Maritime Studies, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kong, People’s Republic of China

a r t i c l e

i n f o

Article history: Received 1 September 2009 Accepted 18 November 2010 Available online 26 November 2010 Keywords: Scheduling Batching Deterioration Release dates Dynamic programming

a b s t r a c t We consider the problem of scheduling n deteriorating jobs with release dates on a single batching machine. Each job’s processing time is an increasing simple linear function of its starting time. The machine can process up to b jobs simultaneously as a batch. The objective is to minimize the maximum completion time, i.e., makespan. For the unbounded model, i.e., b = 1, we obtain an O(n log n) dynamic programming algorithm. For the bounded model, i.e., b < n, we first show that the problem is binary NP-hard even if there are only two distinct release dates. Then we present O( nb) and O((nb/h)h) algorithms for the case where the job processing order is predetermined in advance and for the case where there are h, h P 2, distinct deteriorating rates, respectively. Furthermore, we provide a fully polynomial-time approximation scheme for the case where the number of distinct release dates is a constant. Ó 2010 Elsevier B.V. All rights reserved.

1. Introduction We are given a set of independent and non-preemptively deteriorating jobs J ¼ fJ 1 ; J 2 ; . . . ; J n g that are to be scheduled and processed on a single batching machine. Each job Jj (j = 1, 2, . . . , n) is associated with a deteriorating rate bj > 0 and a release date rj > 0. The processing time pj of job Jj is an increasing simple linear function of its starting time, given by pj = bjt, where t P rj is the starting time of Jj. The machine can process up to b jobs simultaneously as a batch. Jobs processed in the same batch have the same starting time and will have to wait until all the jobs in the batch have completed. Therefore, the processing time of a batch is equal to the largest processing time of the jobs in the batch and the completion time of each job in the batch is defined as the completion time of the batch, i.e., the completion time of the longest job in the batch. This type of batching is referred to as parallel-batch or p-batch. This is different from serial-batch or s-batch, where jobs are processed sequentially with a set-up time for each batch (Brucker, 2001). We investigate two models of the parallel-batch scheduling with deteriorating jobs, namely the unbounded model, i.e., b = 1 (equivalent to b P n), and the bounded model, i.e., b < n. The goal is to find a schedule of the jobs so as to minimize the makespan Cmax, i.e., the completion time of the last job. Extending the standard notation of Graham et al. (1979), we denote the

⇑ Corresponding author. Tel.: +852 2766 7364; fax: +852 2330 2704. E-mail address: [email protected] (C.T. Ng). 0377-2217/$ - see front matter Ó 2010 Elsevier B.V. All rights reserved. doi:10.1016/j.ejor.2010.11.021

unbounded model and bounded model by 1jp-batch, pj = bjt, rj, b = 1jCmax and 1jp-batch, pj = bjt, rj, b < njCmax, respectively. Here, ‘‘pj = bjt’’ indicates that the processing time of a job is an increasing simple linear function of its starting time and ‘‘rj’’ implies that the jobs have individual release dates. Moreover, we will add ‘‘rj = t0’’ if all the jobs are simultaneously available at the same time t0 > 0. As a practical example of the scheduling model under study, we consider the steel-making process in a steel plant (see, e.g., Bachman and Janiak, 2000; Ventura et al., 2002; Gorczyca and Janiak, 2010 for reference). After processing in a mould, stripped ingots are stored in a buffer awaiting the rolling process. The temperatures of the ingots will drop waiting in the buffer. Just before rolling, the ingots need to be preheated in a soaking pit to reach a certain temperature suitable for the rolling process. A soaking pit is a batch furnace that preheats a batch of ingots for the rolling process. The preheating times of the ingots depend on their temperatures at the beginning of the preheating process and their types used to meet different customer requirements. The longer an ingot waits until the start of the preheating process, the lower its temperature drops, so the preheating process takes more time to complete. Consequently, the processing time of an ingot can be modelled as an increasing linear function of its starting time. Ingots can stay in the soaking pit for a period longer than their required times. But no ingot can be removed from the soaking pit during the preheating process. Thus, the minimum preheating time of a batch of ingots is the largest processing time of the ingots in the batch. Note that the ingots may arrive dynamically at the buffer due to their operations in the previous stage or they become available after a certain time instant for the preheating process in

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

the soaking pit due to technical and/or resource constraints, such as the availability of raw materials (e.g., coke, charcoal, or other alloy materials). So ingots have release dates. Scheduling of steel ingot production that inherently involves the above described preheating process can be regarded as dynamic parallel-batch scheduling of jobs with linear deteriorating processing times. The above described scheduling problem falls into the category of scheduling with time-dependent processing times and the category of batch scheduling. Qi et al. (2009) consider closely relevant model. They suppose that all the jobs arrive simultaneously and the batch capacity is infinite. Under this assumption, they show that 1jp-batch, pj = bjt, rj = t0, b = 1jf is polynomially solvable when P P P the objective function f 2 f C j ; wj C j ; Lmax ; U j g and the probP lem is NP-hard when the objective function f is wj U j , where P P P P wj U j are the total completion time, C j ; wj C j ; Lmax ; U j , and total weighted completion time, maximum lateness, number of late jobs, and weighted number of late jobs, respectively. However, to the best of our knowledge, no work has been done on scheduling deteriorating jobs with release dates under the unbounded or bounded batch scheduling model. The first study on scheduling jobs with time-dependent processing times was probably due to Melnikov and Shafransky (1979). Reviews of this area of research were provided by Alidaee and Womer (1999), Cheng et al. (2004) and Gawiejnowicz (2008). Specifically, research on scheduling of jobs with simple linear deterioration may date back to Mosheiov (1994). He presents polynomial-time algorithms for the single-machine problems P P P 1jpj = bjt, rj = t0jf, where f 2 fC max ; C j ; wj C j ; Lmax ; U j g. Chen (1996) and Mosheiov (1998) show that the parallel-machine probP lems P2jpj ¼ bj t; r j ¼ t 0 j C j and P2jpj = bjt, rj = t0jCmax are NP-hard, respectively. Ji and Cheng (2008, 2009) provide fully polynomialP time approximation schemes for Pmjpj ¼ bj t; rj ¼ t0 j C j and Pmjpj = bjt, rj = t0jCmax, while Chen (1996) and Ji and Cheng (2009) show that no polynomial-time approximation algorithm with a P constant worst-case ratio exists for Pjpj ¼ bj t; r j ¼ t 0 j C j and Pjpj = bjt, rj = t0jCmax, respectively. Moreover, Wu and Lee (2003), Ji et al. (2006), Gawiejnowicz (2007), Cheng and Sun (2009), Gawiejnowicz et al. (2009), Gawiejnowicz and Kononov (2010), and Lodree and Geiger (2010) present new models and approximation algorithms for scheduling of simple linear deteriorating jobs subject to machine or job availability constraints. The classical batch scheduling models relevant to this study have been addressed by different researchers. Lee and Uzsoy (1999) provide a polynomial-time algorithm for the unbounded model 1jp-batch, rj, b = 1jCmax. With respect to the bounded model 1jp-batch, rj, b < njCmax, Brucker et al. (1998) prove that it is strongly NP-hard when the number of distinct release dates is arbitrary. Liu and Yu (2000) show that it is ordinarily NP-hard even if there are only two distinct release dates. Deng et al. (2003) and Poon and Zhang (2004) provide polynomial-time approximation schemes. Li et al. (2005) present a polynomial-time approximation scheme for Pjp-batch, rj, b < njCmax. Extensive surveys of researches with batching can be found in Webster and Baker (1995), Potts and Kovalyov (2000), and Mathirajan and Sivakumar (2006). The remainder of the paper is organized as follows. In Section 2 we introduce some notation and basic lemmas. In Section 3 we present an O(n logn) dynamic programming algorithm for the unbounded model. In Section 4, for the bounded model, we first show that it is binary NP-hard even if there are only two distinct release dates. Then we present O(nb) and O((nb/h)h) algorithms for the case where the job processing order is predetermined in advance and for the case where there are h distinct deteriorating rates, respectively. We also propose a fully polynomial-time approximation scheme for the case where the number of distinct release dates is a constant. In Section 5 we conclude the paper and suggest some topics for future research.

483

2. Preliminaries A subset B of jobs is called a batch. A batch B is full if jBj = b. A batch that is not full is called a partial batch. The deteriorating rate of a batch is defined as the largest deteriorating rate of the jobs in the batch. The following notation is used throughout this paper:     

pj = bjt, the processing time of job Jj starting at time t; b(B) = max{bj: Jj 2 B}, the deteriorating rate of batch B; r(B) = max{rj: Jj 2 B}, the release date of batch B; p(B) = max{pj: Jj 2 B}, the processing time of batch B; bmax ¼ maxfbj : J j 2 J g, the largest deteriorating rate of all jobs in J .

Lemma 2.1 (Mosheiov, 1994). For 1jpj = bjt, rj = t0jCmax, the maxiQ mum completion time of the jobs is equal to C max ðJ Þ ¼ t 0 Jj 2J ð1 þ bj Þ and it does not depend on the processing order of the jobs. We have the following similar lemma for 1jp-batch, pj = bjt, rj = t0, b < njCmax. Lemma 2.2. For 1jp-batch, pj = bjt, rj = t0, b < njCmax, if the set of batches to be processed is B ¼ fB1 ; B2 ; . . . ; Bm g, then the maximum completion time of the batches (or jobs) under an optimal schedule is Q equal to C max ¼ t 0 m i¼1 ð1 þ bðBi ÞÞ and it does not depend on the processing order of the batches. Lemma 2.3. For 1jp-batch, pj = bjt, rj, b < njCmax, if r = (B1, B2, . . . , Bm) is the processing order of the batches such that the machine starts executing batches without idle time whenever a batch is available, then the makespan is equal to

(

C max ðrÞ ¼ max

16i6m

rðBi Þ

) m Y ð1 þ bðBj ÞÞ :

ð1Þ

j¼i

Proof. We use sj and Cj to denote the starting time and completion time of batch Bj, respectively. We prove the lemma by induction on the number of processing batches. When m = 1, p(B1) = s1b(B1) = r(B1)b(B1), so Cmax(r) = C1 = s1 + p(B1) = r(B1) (1 + b(B1)). Hence (1) holds for n m = 1. Assume thato (1) is satisfied Q for m = k, i.e., C k ¼ max16i6k rðBi Þ kj¼i ð1 þ bðBj ÞÞ . For m = k + 1, we have C nkþ1 ¼Q skþ1 þ pðBkþ1 Þ ¼ maxfC k ; rðBkþ1 Þgð1 þ bðBkþ1 ÞÞ ¼ kþ1 ð1 þ bðBj ÞÞg. The result holds. h max16i6kþ1 rðBi Þ j¼i Bartholdi (1988) shows that the Full Batch Largest Processing Time (FBLPT) rule is optimal for 1jp-batch, rj = t0, b < njCmax. For the bounded batching machine with deteriorating jobs, we obtain a similar batching rule in O(n logn) time as follows: Algorithm FBLDR (Full Batch Largest Deteriorating Rate) Step 1. Index the jobs such that b1 P b2 P    P bn and obtain a job list. Step 2. If there are more than b jobs in the job list, then place the first b jobs in a batch and iterate. Otherwise, place the remaining jobs in a batch. Step 3. Schedule the batches in an arbitrary order at time t0.

Lemma 2.4. Algorithm FBLDR solves problem 1jp-batch, pj = bjt, rj = t0, b < njCmax in O(n logn) time. Proof. Suppose that we re-index the jobs in non-increasing order of their deteriorating rates. From Lemma 2.2, once the batches are determined, the makespan does not depend on the processing

484

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

order of the batches. Therefore we only need to prove that there exists an optimal schedule satisfying the following properties: (i) all the batches contain consecutive jobs and (ii) all the batches, except possibly the one containing the highest indexed job, are full. Consider an optimal schedule and two batches A and B. Suppose that there are three jobs Ji, Jj, and Jk with bi 6 bj < bk such that Ji, Jk 2 A and Jj 2 B. We obtain a new schedule by shifting job Ji to batch B and job Jj to batch A. Write A* = (An{Ji}) [ {Jj} and B* = (Bn{Jj}) [ {Ji}. Since bi 6 bj < bk, we have p(A*) = p(A) and p(B*) 6 p(B). So the new schedule remains optimal. A finite number of repetitions of this procedure yields an optimal schedule such that all the batches contain consecutive jobs. Hence property (i) holds. We can also prove property (ii) by the job shifting procedure. h

3. The unbounded model In this section we consider the unbounded model 1jp-batch, pj = bjt, rj, b = 1jCmax. We give a dynamic programming algorithm to solve the problem in O(n logn) time. The unbounded model 1jp-batch, pj = bjt, rj, b = 1jCmax is interesting in its own right, as well as being useful in obtaining a lower bound on the optimal value of the bounded model 1jp-batch, pj = bjt, rj, b < njCmax. Lemma 3.1. For 1jp-batch, pj = bjt, rj, b = 1jCmax, there exists an optimal batch processing order r = (B1, B2, . . . , Bm) such that if two jobs Ji and Jj belong to distinct batches with Ji 2 Bx, Jj 2 By, and x < y, then bi > bj. Proof. Let r = (B1, B2, . . . , Bm) be an optimal batch processing order for 1jp-batch, pj = bjt, rj, b = 1jCmax such that the property of Lemma 3.1 does not hold. Then there are two jobs Ji and Jj that belong to distinct batches such that Ji 2 Bx and Jj 2 By with x < y, but bi 6 bj. Since b = 1, there is no limit on the number of jobs in a batch. Therefore we can obtain a new batch order r0 by shifting job Ji from Bx to By. This does not delay the completion time of any batch. So r0 is optimal too. Repeating this procedure, we eventually obtain an optimal batch processing order with the required property. h Corollary 3.2. There exists an optimal batch processing order r = (B1, B2, . . . , Bm) for problem 1jp-batch, pj = bjt, rj, b = 1jCmax such that each batch Bx is in the form Bx ¼ fJ j 2 J : l 6 bj 6 ug for some numbers l and u. By Corollary 3.2, if there are two jobs Ji and Jj such that ri 6 rj and bi 6 bj, we can delete job Ji from the job set. This procedure can be performed in O(n logn) time. Hence, in the sequel, we suppose that any two jobs Ji and Jj have different release dates and different deteriorating rates, and ri < rj implies bi > bj. Then the jobs can be re-indexed such that r1 < r2 <    < rn and b1 > b2 >    > bn. Algorithm (DP1). Define F(k) as the minimum makespan Cmax of a partial schedule of the jobs J1, J2, . . . , Jk. The general strategy is to schedule J1, J2, . . . , Ji, for some 0 6 i < k, in the best way and then schedule Ji+1, . . . , Jk in the same batch at time rk or F(i), whichever comes later. The initial condition is F(0) = 0 and the recursive formula for F(k) is given by

FðkÞ ¼ min fmaxfFðiÞ; r k g  ð1 þ biþ1 Þg: 06i6k1

The optimal solution value is F(n). A straightforward implementation of the algorithm requires O(k) time to compute F(k), given F(i), 0 6 i 6 k  1, so algorithm DP1 runs in O(n2) time. Adopting the technique provided by Poon and Zhang (2004), we can reduce the running time of DP1 to O(n logn) as follows: first, we compute F(0), F(1), . . . , F(n) one by one and store the results in an

array [F(0), F(1), . . . , F(n)]. Second, we make use of the work done in computing F(k  1) to speed up the computation of F(k). Note that F is monotonic non-decreasing, i.e., F(0) 6 F(1) 6    6 F(n). Therefore, we can find an index mk such that F(mk) 6 rk < F(mk + 1). Then max{F(i), rk} = rk if i 6 mk and max{F(i), rk} = F(i) otherwise. Hence

  FðkÞ ¼ min r k ð1 þ bmk þ1 Þ; Fðmk þ 1Þð1 þ bmk þ2 Þ; . . . ; Fðk  1Þð1 þ bk Þ : Let Ak = {F(i)(1 + bi+1): mk + 1 6 i 6 k  1}. To obtain Ak+1 from Ak, we compute mk+1 (by a sequential search for rk+1 on [F(mk + 1), . . . , F(n)]), delete the elements in AknAk+1 (={F(i)(1 + bi+1): mk + 1 6 i 6 mk+1}), and insert the element F(k)(1 + bk+1). Third, we store Ak as a heap and keep an array P of pointers so that P[i] points to the element F(i)(1 + bi+1) in the heap when it is inserted. Note that finding the minimum value in Ak takes constant time and each value of the form F(k)(1 + bk+1) is inserted into and deleted from the heap at most once. Therefore, our algorithm requires O(n logn) time in total. Theorem 3.3. 1jp-batch, pj = bjt, rj, b = 1jCmax can be solved in O(n logn) time.

4. The bounded model In this section we study the bounded model 1jp-batch, pj = bjt, rj, b < njCmax. We first show that the problem is binary NP-hard even if there are only two distinct release dates. Then we present O(nb) and O((nb/h)h) algorithms for the case where the job processing order is predetermined in advance and for the case where there are h distinct deteriorating rates, respectively. We further propose a fully polynomial-time approximation scheme for the case where the number of distinct release dates is a constant. 4.1. NP-hardness proof In this subsection we show that 1jp-batch, pj = bjt, rj, b = 2jCmax is computationally intractable by performing a reduction from the following strongly NP-complete Product Partition problem (Ng et al., 2010). Product Partition: Given a set of m positive integers a1, a2, . . . , Q am, is there a subset X # M :¼ {1, 2, . . . , m} such that i2X ai ¼ Q i2MnX ai ? Theorem 4.1.1. 1jp-batch, pj = bjt, rj, b = 2jCmax is binary NP-hard even if there are only two distinct release dates. Proof. The decision version of the scheduling problem is clearly in NP. Given an arbitrary instance of Product Partition, we construct an instance of the scheduling problem as follows: there are pffiffiffiffi Q n = 4m jobs of m types. Let H ¼ i2M ai and A ¼ H. For each i = 1, . . .,m, we have four jobs Ji1, Ji2, Ji3, and Ji4 of type i. Their deteriorating rates and release dates are given by

bi1 ¼ A4i ai  1; 4i

r i1 ¼ r 1 ¼ 1;

bi2 ¼ bi3 ¼ A =ai  1; 4i

bi4 ¼ A  1;

ri2 ¼ ri3 ¼ r 1 ¼ 1;

r i4 ¼ r 2 ¼ A2m

2 þ2m

: 2

The threshold value is given by Y ¼ A4m þ4mþ1 . The decision asks whether there is a schedule for problem 1jp-batch, pj = bjt, rj, b = 2jCmax with Cmax 6 Y. h Clearly, the above reduction can be done in time polynomial of the length of problem Product Partition. We show that there is a required subset for problem Product Partition if and only if there is a schedule for 1jp-batch, pj = bjt, rj, b = 2jCmax with Cmax not great2 er than Y ¼ A4m þ4mþ1 .

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

Q

Q

Assume that there is a subset X such that i2X ai ¼ i2MnX ai . Without loss of generality, we suppose that X = {1, 2, . . . , k}. Then we define a schedule in the following way:

J11 ; . . . ; J k1 ; J kþ1;3 ; . . . ; J m3 ; J 13 ; . . . ; J k3 ; J kþ1;1 ; . . . ; J m1 ; J12 ; . . . ; J k2 ; J kþ1;2 ; . . . ; J m2 ; J 14 ; . . . ; J k4 ; J kþ1;4 ; . . . ; J m4 ; where the two jobs in the same column are processed as a batch. It can be verified that the makespan Cmax of the schedule is exactly Y. Conversely, assume that there is a schedule (say p) with Cmax(p) 6 Y. We need to show that there is a subset X for problem Q Q Product Partition with i2X ai ¼ i2MnX ai . Claim 1. Every batch in schedule p contains two jobs of the same type. Proof of Claim 1. For each batch B in schedule p, define q(B) = max{1 + bij: Jij 2 B}/min{1 + bij: Jij 2 B} if jBj = 2, and q(B) = {1 + bij: Jij 2 B} if jBj = 1. In either case, the deteriorating rate of batch B is Q bðBÞ ¼ ½qðBÞ Jij 2B ð1 þ bij Þ1=2  1. By Lemma 2.3, we have

C max ðpÞ P r 1

Y

"

Y

ð1 þ bðBÞÞ ¼

B2p

"

Y

¼

!

qðBÞ 

B2p

! qðBÞ 

B2p

m Y

m Y 4 Y

!#1=2

ð1 þ bij Þ

i¼1 j¼1

!#1=2 16i

A =ai

2 þ4mþ1

Since C max ðpÞ 6 Y ¼ A4m

, we have

4

qðBÞ 6 A :

ð2Þ

B2p

For a batch B in p containing a single job or two jobs of distinct types, it is easy to check that q(B) > A2. If Claim 1 does not hold, then due to the fact that the number of jobs of each type is even, there are two batches B0 and B00 in p such that each of them contains a single job or two jobs of distinct types. But then, q(B0 )q(B00 ) > A4, contradicting (2). This completes the proof of Claim 1. h Since for each i = 1, . . . , m, Ji2 is identical to Ji3, there are only two ways to partition four jobs of type i into two batches: either {Ji1, Ji2} and {Ji3, Ji4} or {Ji1, Ji4} and {Ji2, Ji3}. Without loss of generality, we suppose that the two batches of type i are {Ji1, Ji2} and {Ji3, Ji4} for i = 1, 2, . . . , k and {Ji1, Ji4} and {Ji2, Ji3} for i = k + 1, k + 2, . . . , m. Note 2 that ri1 = ri2 = ri3 = r1 = 1 and ri4 ¼ r 2 ¼ A2m þ2m . Then the following batch processing order r is not worse than p:

J11 ; . . . ; J k1 ; J kþ1;3 ; . . . ; J m3 ; J 13 ; . . . ; J k3 ; J kþ1;1 ; . . . ; J m1 ; J12 ; . . . ; J k2 ; J kþ1;2 ; . . . ; J m2 ; J 14 ; . . . ; J k4 ; J kþ1;4 ; . . . ; J m4 ; where the two jobs in the same column are processed as a batch. By Lemma 2.3, we have

( C max ðrÞ ¼ max r 1 

k Y

ð1 þ bi2 Þ; r2



k Y

ð1 þ bi4 Þ

i¼1

i¼kþ1

2 þ4m

(  max

k Y

!,

4m2 þ4m

 max

( k Y i¼1

m Y

ai

i¼1

¼A

)

ð1 þ bi1 Þ

i¼kþ1

¼ A4m

m Y

ð1 þ bi1 Þ 

i¼1 m Y

m Y

ai

6 A:

ð3Þ

i¼kþ1

Q Q Qk Qm 2 Note that m i¼1 ai ¼ i¼1 ai ¼ i¼kþ1 i2M ai ¼ H ¼ A . By (3), we have ai ¼ A. Therefore, X = {1, 2, . . . , k} is a required subset of problem Product Partition. h Remark 1. In the above NP-hardness proof, we have used large numbers for the deteriorating rates of the jobs (all bj’s are larger than 1). One can observe that the scaling method (via dividing all the numbers in the input by a large number) is not applicable to the present reduction. This means that the above NP-hardness proof cannot be directly used to the subcase with bj 6 1 for all jobs. Hence, the complexity of the problem with the deteriorating rates at most 1 is still open. 4.2. Scheduling under predetermined job processing order In this subsection we investigate the case where the job processing order is predetermined in advance. Without loss of generality, suppose the jobs are indexed according to the order they appear in the predetermined order. If Ji and Jj are two jobs with i < j, then we require that Ci(p) 6 Cj(p) in any feasible schedule p. The following dynamic programming algorithm is a generalization of DP1 in Section 3. Algorithm (DP2). Let F(k) be the minimum makespan Cmax of a partial schedule containing jobs J1, J2, . . . , Jk. As in DP1, the initial condition is F(0) = 0 and the optimal value is given by F(n). The recursion for k = 1, 2, . . . , n is

B2p



i¼1

ai ;

485

)

i¼1

Y 2 ¼ ½ qðBÞ1=2  A4m þ4m1 :

Y

max

( k Y

ai ;

!

i¼kþ1

m Y

)

ai ; 1

)

ai :



m Y

ai

FðkÞ ¼

min

ðkbÞþ 6i6k1

fmaxfFðiÞ; r k g  ð1 þ biþ1;k Þg;

where (k  b)+ = max{k  b, 0} and bij = max{bl: i 6 l 6 j}. Since we can evaluate bij in advance for all i, j with j 6 i + b  1 in O(nb) time, there are n states to examine and each state can be evaluated in O(b) time. Hence the computational complexity of algorithm DP2 is O(nb). Note that if the job release dates and deterioration rates are agreeable (i.e., ri < rj implies bi 6 bj), using the job-interchange argument, we can show that there exists an optimal schedule in which the job processing order is in a non-decreasing order of their deteriorating dates. In this case we can determine the processing order of the jobs and use algorithm DP2 to solve the problem in O(nb) time. Finally, if the release dates and deteriorating rates are reverse agreeable, i.e., ri < rj implies bi P bj, we can also show that there exists an optimal schedule in which the job processing order is in a non-increasing order of their deteriorating rates. Thus we can again use algorithm DP2 to solve the problem in O(nb) time. 4.3. Scheduling with h distinct deteriorating rates In this subsection we present an algorithm whose running time is sensitive to the number of distinct deteriorating rates. Let b1, b2, . . . , bh be the h(h P 2) distinct deteriorating rates. For simplicity, we call the jobs with deterioration bi being of type i. The set of all the jobs of type i is denoted by Ti. Let ni be the number of jobs P in Ti. Then hi¼1 ni ¼ n. For ease of exposition, denote by Jij the jth job in type Ti and rij its corresponding release date for i = 1, . . . , h and j = 1, . . . , ni.

i¼kþ1

Lemma 4.3.1. There exists an optimal schedule in which jobs of the same type are processed in a non-decreasing order of their release dates.

i¼kþ1 2 þ4mþ1

Since C max ðrÞ 6 C max ðpÞ 6 Y ¼ A4m

, we have

Proof. It can be proved by the job-interchange argument. h

486

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

The following lemma shows that there exists an optimal schedule in which each given type Tu of jobs is assigned to either one batch or several batches, where in the case of several batches, only the first batch may not be full. Lemma 4.3.2. There exists an optimal schedule in which, for each given type T u ðu ¼ 1; . . . ; hÞ; jBu½1 j 6 b and jBu½k j ¼ b for k P 2, where Bu½k denotes the kth batch among the batches (indexed in an increasing order of their completion times) containing some jobs of type Tu. Proof. Note that jBu½k j is the size of the entire batch including the jobs not only of type Tu but also of some other types. It is required for the given problem that any optimal schedule satisfies the relations jBu½i j 6 b for each given type Tu and each associated batch i. If there is a certain Tu with 1 6 jBu½k j < b for some k P 2, then we can always shift some jobs of Tu from Bu½i ð1 6 i 6 k  1Þ to Bu½k without increasing the completion times of the batches. This procedure can be repeated until the required property holds. h The above two lemmas present how each type of jobs has to be sequenced. However, it is still necessary to determine both the size and components of each batch. For this purpose, we develop a dynamic programming algorithm using the results of Lemmas 4.3.1 and 4.3.2. For the algorithm, by Lemma 4.3.1, the jobs belonging to the same type will first be indexed such that r i1 6 r i2 6    6 rini for i = 1, 2, . . . , h. Algorithm (DP3). Let F(a1, a2, . . . , ah) be the minimum makespan of all the schedules of the job set J a1 ;...;ah ¼ fJ ij : 1 6 i 6 h; 1 6 j 6 ai g. To obtain F(a1, a2, . . . , ah), we further introduce G(a1, a2, . . . , ah; s1, s2, . . . , sh) as the minimum makespan to schedule the job set J a1 ;...;ah such that the following properties hold: (a) the last batch contains the last sk jobs of type Tk (i.e., fJ k;ak sk þ1 ; . . . ; J kak g) for k = 1, 2, . . . , h; (b) 0 6 si 6 ai, 1 6 i 6 h; (c) the size of the last batch is limited to the batch capacity, i.e, Ph i¼1 si 6 b. For simplicity, write A = (a1, a2, . . . , ah) and S = (s1, s2, . . . , sh). Then we have

FðAÞ ¼ Fða1 ; a2 ; . . . ; ah Þ ¼ minfGðA; SÞ : 0 6 si 6 ai for 1 6 i 6 h and 1 6

X

si 6 bg

16i6h

O(bh) time, since we have at most b choices for each si with 1 6 i 6 h. Therefore the overall time complexity of DP3 is O((bn/ h)h), which is polynomial if h is a constant. 4.4. Scheduling with m distinct release dates An algorithm A is a (1 + q)-approximation algorithm for a minimization problem if it produces a solution that is at most of (1 + q) times the optimal solution. A family of algorithms {A:  > 0} is called a fully polynomial-time approximation scheme (FPTAS) if, for each  > 0, the algorithm A is a (1 + )-approximation algorithm running in polynomial time in the input size and 1/. From now on we assume, without loss of generality, that 0 <  6 1. If  > 1, then a 2-approximation algorithm can be taken as a (1 + )-approximation algorithm. Let q1, q2, . . . , qm be the m (a constant), m P 2, distinct release dates satisfying 0 < q1 < q2 <    < qm. Without loss of generality, we assume that q1 = 1, which can be achieved by normalizing the time scale with respect to the minimum release date q1. We partition the interval [q1, +1) into m disjoint segments [q1, q2), [q2, q3), . . ., [qm, qm+1), where q1 = 1 and qm+1 = +1. For simplicity, denote by Di the ith time interval [qi, qi+1) for i = 1, 2, . . . , m. In the following we derive an FPTAS for the case where the number of distinct release dates m is a constant. This is done by applying the ‘‘rounding-the-input-data’’ technique of Sahni (1976) to a given problem instance. Specifically, we design the FPTAS by considering the rounded instance of 1jp-batch, pj = bjt, rj, b < njCmax, which is defined later. The definition of the rounded instance involves the ‘‘geometric-rounding’’ technique, which can be stated as follows: for any 0 > 0 and x P 1, if (1 + 0 )k1 < x 6 (1 + 0 )k, define dxe0 ¼ ð1 þ 0 Þk .  . The rounded instance is defined Given 0 <  6 1, write 0 ¼ 2ðnþ1Þ as follows: we round up the deteriorating rate bj of job Jj to 0 0 bj ¼ d1 þ bj e0  1. Let Lj denote the exponent of 1 þ bj , i.e., logd1þb e

0

1 þ bj ¼ ð1 þ 0 ÞLj , then Lj ¼ logð1þj 0 Þ . It can be observe that Lj 6  

n logð1þbj Þ if bj P 1, and Lj 6 O n if 0 < bj < 1. Similarly, we round O  0

up the release date qj to q0j ¼ dqj e0 . Let Mj denote the exponent of logdqj e0 q0j , i.e., q0j ¼ ð1 þ 0 ÞMj , then Mj ¼ logð1þ 0 Þ. Under this definition, we

have M1 = 0. For simplicity, we retain the notation rj for the rounded release date of job Jj. Lemma 4.4.1. For 1jp-batch, pj = bjt, rj, b < njCmax, the optimal objective value of the rounded instance is at most of (1 + ) times of the optimal objective value of the original instance.

and

GðA; SÞ ¼ maxfFða1  s1 ; . . . ; ah  sh Þ; uðA; SÞg  ð1 þ /ðA; SÞÞ; where uðA; SÞ ¼ maxfr iai : si > 0; 1 6 i 6 hg and /(A, S) = max{bi: si > 0, 1 6 i 6 h} denote the release date and deteriorating rate of the last batch composed of the job subset J a1 ;...;ah n J a1 s1 ;...;ah sh , respectively. The initial condition is F(0, 0, . . . , 0) = 0 and

8 þ1; if si > minfb; ai g; > > >  h  > > h > < þ1; if P s > min b; P a ; i i GðA; SÞ ¼ i¼1 i¼1 > > > h P > > > þ1; if 0 < si0 < ai0 for some i0 and si < b; : i¼1

where the last possibility follows from Lemma 4.3.2. The optimal value is given by F(n1, n2, . . . , nh) and the corresponding optimal schedule can be found by backtracking. Algorithm DP3 has at most (n1 + 1) (n2 + 1). . .(nh + 1) 6 ((n/ Ph h) + 1)h states (recall that i¼1 ni ¼ n). Each iteration requires

Proof. Let r = (B1, B2, . . . , Bm) be a batch processing order for 1jpbatch, pj = bjt, rj, b < njCmax. By Lemma 2.3, the makespan of the original instance is

( C max ðrÞ ¼ max

16i6m

rðBi Þ

m Y

) ð1 þ bðBj ÞÞ :

j¼i

Similarly, the makespan of the rounded instance is

( C 0max ð

0

rÞ ¼ max r ðBi Þ 16i6m

( ¼ max

16i6m

m Y

) 0

ð1 þ b ðBj ÞÞ

j¼i

drðBi Þe0

m Y

) d1 þ bðBj Þe0

j¼i

(

0 nþ1

6 ð1 þ  Þ

max

16i6m

6 ð1 þ ÞC max ðrÞ:

rðBi Þ

m Y j¼i

) ð1 þ bðBj ÞÞ

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

The penultimate inequality is justified by noting that m 6 n and  . The last inequality foldxe0 6 ð1 þ 0 Þx for all x P 1 and 0 ¼ 2ðnþ1Þ

y m lows from 1 þ m 6 1 þ 2y for all the real numbers y with 0 6 y 6 1 and for integers m P 1. h Combining the results of Lemmas 2.2 and 2.4, we have the following lemma. Lemma 4.4.2. There exists an optimal schedule with the property that for the jobs scheduled (started but not necessarily finished) within the same interval Di (1 6 i 6 m), those with largest deteriorating rates are scheduled first and each batch is a full batch except possibly the last one. As a consequence of Lemma 4.4.1, with a (1 + ) loss, we can focus our attention on the rounded instance of problem 1jp-batch, pj = bjt, rj, b < njCmax. In the following we design an exact dynamic programming formulation for the rounded instance of the scheduling problem. The idea behind the dynamic programming algorithm mainly relies on the structural properties described in Lemma 4.4.2. Moreover, from Lemmas 2.2 and 2.3, we observe that there exists an optimal schedule in which the starting times and completion times of all the batches (jobs) are in the form of (1 + 0 )k, where k is a nonnegative integer. By Lemma 4.4.2, we can assume that the jobs are indexed such that b1 P b2 P    P bn. Furthermore, define D0i ¼ ½q0i ; q0iþ1 Þ for i = 1, 2, . . . , m and sk = (1 + 0 )k.

Algorithm (DP4). Let F(s1, s2, . . . , sm) denote the minimum makespan of all the schedules for the n jobs, subject to the restriction that the first batch starting in D0i (if it exists) starts at time ssi ¼ ð1 þ 0 Þsi , i = 1, 2, . . ., m. Clearly we may require that s1 = 0 and si = Mi, Mi + 1, . . . , Mi + L1  1 for i = 2, . . . , m. Then (s1, s2, . . . , sm) has at most O((L1)m1) configurations. Now assume that some start vector s = (s1, s2, . . . , sm) is given. To obtain F(s), we further introduce G(j; c1, . . . ,,cm; x1, . . . , xm1) as the minimum makespan to schedule the jobs of J1, J2, . . . , Jj such that the batches with starting times in D0k satisfy the following two properties: (i) the last batch contains ck jobs (1 6 k 6 m); (ii) the completion time of the last batch is sk sxk (1 6 k 6 m  1). Then we can determine the domain of G(j; c1, . . . , cm; x1, . . . , xm1) by (D1) (D2) (D3) (D4)

0 6 j 6 n; P 1 6 ck 6 bð1 6 k 6 mÞ; m k¼1 c k ¼ jðmod bÞ; Pj 0 6 xk 6 i¼1 Li ð1 6 k 6 m  1Þ; sk sxk 6 skþi , if xk+1 = xk+2 =    = xk+i1 = 0 (1 6 k 6 m  1, 1 6 i 6 m  k).

and

xk+i > 0

Note that xk = 0 means that no batch starts in D0k ð1 6 k 6 m  1Þ and that the domain of G(j; c1, . . . , cm; x1, . . . , xm1) has at most 

m1  m Pn O nb configurations. i¼1 Li We define that G(j; c1, . . . , cm; x1, . . . , xm1) takes value +1 when no feasible schedule with properties (i) and (ii) exists. Initially, define G(0; b, . . . , b; 0, . . . , 0) = sm, and for any other cases, G(0; c1, . . . , cm; x1, . . . , xm1) = +1. Then the recursive formula can be expressed as follows:

Gðj; c1 ; . . . ; cm ; x1 ; . . . ; xm1 Þ ¼ minfHi : 1 6 i 6 m and q0i P rj g; where

Hi ¼

487

8 Gðj  1; c1 ; . . . ; ci1 ; b; ciþ1 ; . . . ; cm ; x1 ; . . . ; xi1 ; > > > > > > x  Lj ; xiþ1 ; . . . ; xm1 Þ; if ci ¼ 1 and i < m; > > i > > < Gðj  1; c1 ; . . . ; cm1 ; b; x1 ; . . . ; xm1 ÞsL ; j > if ci ¼ 1 and i ¼ m; > > > > > > Gðj  1; c1 ; . . . ; ci1 ; ci  1; ciþ1 ; . . . ; cm ; x1 ; . . . ; xm1 Þ; > > > : if ci > 1:

In the above formula, to guarantee the optimality of G(j; c1, . . . , cm; x1, . . . , xm1), we enumerate all the possibilities of the positions for job Jj, i.e., job Jj is to be assigned to the last batch among the batches that start in D0i for each q0i P r j . Then for any s = (s1, s2, . . . , sm), F(s) is evaluated after the iterative process and it is in the form of

FðsÞ ¼

min

ðc1 ;...;cm ;x1 ;...;xm1 Þ

fGðn; c1 ; . . . ; cm ; x1 ; . . . ; xm1 Þg;

where ck and xk run over their domains (D1)–(D4). The optimal solution value of the rounded problem is equal to min F(s) and the corresponding optimal schedule can be found by backtracking. Theorem 4.4.3. When the number of distinct release dates m is a constant, there exists an FPTAS for 1jp-batch, pj = bjt, rj, b < njCmax, Pn which runs in O((1/)2m2n2m1bmTm1) time, where T ¼ i¼1 max flogð1 þ bi Þ; 1gÞ logð1 þ bmax Þ.

Proof. By Lemmas 4.4.1 and 4.4.1 and the above analysis, we know that algorithm DP4 is an (1 + )-approximation algorithm for 1jpbatch, pj = bjt, rj, b < njCmax. Therefore we only need to estimate the time complexity of algorithm DP4. Note that the indexing step can be done in O(n logn) time, while in algorithm DP4, we need to compute O((L1)m1) configurations for s = (s1, s2, . . ., sm) and each compu m1 m Pn tation of such configuration takes at most Oðnb Li Þ time. i¼1

P m1 m n Thus, the algorithm requires Oðnb Li ðL1 Þm1 Þ ¼ i¼1 Pn m Oðð1=Þ2m2 n2m1 b T m1 Þ time, where T ¼ i¼1 maxflogð1þ bi Þ; 1gÞ logð1 þ b1 Þ. h 5. Conclusions We study parallel-batch scheduling of deteriorating jobs with release dates on a single machine. In this problem jobs are processed in batches and each job’s processing time is a simple linear increasing function of its starting time. The objective is to minimize the makespan. For the unbounded model, we present an O(n logn) dynamic programming algorithm. For the bounded model, we show that the problem is binary NP-hard even if there are only two distinct release dates; for the case where the job processing order is predetermined in advance and the case with h distinct deteriorating rates, we give O(nb) and O((nb/h)h) algorithms, respectively. We also provide an FPTAS for the case where the number of distinct release dates is a constant. An open question is whether there exists a polynomial-time algorithm with a constant worst-case ratio for the general case where the number of distinct release dates is arbitrary. Analysis of the complexity status of the models (unbounded or bounded) studied in this paper with different objectives, e.g., minimizing the sum of job completion times, is another worthy topic for future research. Furthermore, one may continue our research with the same objective, but focus on the alternative assumption that the processing time of a job Jj starting at time t is a simple linear increasing function of its waiting time, i.e., pj = aj + bj(t  rj).

488

S. Li et al. / European Journal of Operational Research 210 (2011) 482–488

Acknowledgments We thank three anonymous reviewers for their helpful and detailed comments on an earlier version of our paper. This research was supported in part by The Hong Kong Polytechnic University under grant number J-BB7J and NSFC-RGC (70731160633). Li and Yuan were also supported by NSFC (10971201) and NSFC (10901142).

References Alidaee, B., Womer, N.K., 1999. Scheduling with time dependent processing times: Review and extensions. Journal of the Operational Research Society 50, 711– 720. Bachman, A., Janiak, A., 2000. Minimizing maximum lateness under linear deterioration. European Journal of Operational Research 126, 557–566. Bartholdi, J.J., 1988. Unpublished manuscript. Brucker, P., 2001. Scheduling Algorithms. Springer, Berlin. Brucker, P., Gladky, A., Hoogeveen, J.A., Kovalyov, M.Y., Potts, C.N., Tautenhahn, T., van de Velde, S.L., 1998. Scheduling a batching machine. Journal of Scheduling 1, 31–54. Chen, Z.L., 1996. Parallel machine scheduling with time dependent processing times. Discrete Applied Mathematics 70, 81–93. Cheng, Y.S., Sun, S.J., 2009. Scheduling linear deteriorating jobs with rejection on a single machine. European Journal of Operational Research 194, 18–27. Cheng, T.C.E., Ding, Q., Lin, B.M.T., 2004. A concise survey of scheduling with timedependent processing times. European Journal of Operations Research 152, 1– 13. Deng, X.T., Poon, C.K., Zhang, Y.Z., 2003. Approximation algorithms in batch processing. Journal of Combinatorial Optimization 7, 247–257. Gawiejnowicz, S., 2007. Scheduling deteriorating jobs subject to job or machine availability constraints. European Journal of Operational Research 180, 472– 478. Gawiejnowicz, S., 2008. Time-Dependent Scheduling. Springer, Berlin. Gawiejnowicz, S., Kononov, A., 2010. Complexity and approximability of scheduling resumable proportionally deteriorating jobs. European Journal of Operational Research 200, 305–308. Gawiejnowicz, S., Kurc, W., Pankowska, L., 2009. Equivalent time-dependent scheduling problems. European Journal of Operational Research 196, 919–929. Gorczyca, M., Janiak, A., 2010. Resource level minimization in the discretecontinuous scheduling. European Journal of Operational Research 203, 32–41. Graham, R.L., Lawler, E.L., Lenstra, J.K., Rinnooy Kan, A.H.G., 1979. Optimization and approximation in deterministic sequencing and scheduling: A survey. Annals of Discrete Mathematics 5, 287–326.

Ji, M., Cheng, T.C.E., 2008. Parallel-machine scheduling with simple linear deterioration to minimize total completion time. European Journal of Operational Research 188, 342–347. Ji, M., Cheng, T.C.E., 2009. Parallel-machine scheduling of simple linear deteriorating jobs. Theoretical Computer Science 410, 3761–3768. Ji, M., He, Y., Cheng, T.C.E., 2006. Scheduling linear deteriorating jobs with an availability constraint on a single machine. Theoretical Computer Science 362, 115–126. Lee, C.Y., Uzsoy, R., 1999. Minimizing makespan on a single batch processing machine with dynamic job arrivals. International Journal of Production Research 37, 219–236. Li, S., Li, G., Zhang, S., 2005. Minimizing makespan with release times on identical parallel batching machines. Discrete Applied Mathematics 148, 127–134. Liu, Z.H., Yu, W.C., 2000. Scheduling one batch processor subject to job release dates. Discrete Applied Mathematics 105, 129–136. Lodree, E.J., Geiger, C.D., 2010. A note on the optimal sequence position for a ratemodifying activity under simple linear deterioration. European Journal of Operational Research 201, 644–648. Mathirajan, M., Sivakumar, A.I., 2006. A literature review, classification and simple meta-analysis on scheduling of batch processors in semiconductor. International Journal of Advanced Manufacturing Technology 29, 990–1001. Melnikov, O.I., Shafransky, Y.M., 1979. Parametric problem of scheduling theory. Kibernetika (in Russian) 3, 55–57 (English translation: Cybernetics 15 (1980) 352–357)). Mosheiov, G., 1994. Scheduling jobs under simple linear deterioration. Computers and Operations Research 21, 653–659. Mosheiov, G., 1998. Multi-machine scheduling with linear deterioration. INFOR 36, 205–214. Ng, C.T., Barketau, M.S., Cheng, T.C.E., Kovalyov, M.Y., 2010. Product Partition and related problems of scheduling and systems reliability: Computational complexity and approximation. European Journal of Operational Research 207, 601–604. Poon, C.K., Zhang, P.X., 2004. Minimizing makespan in batch machine scheduling. Algorithmica 39, 155–174. Potts, C.N., Kovalyov, M.Y., 2000. Scheduling with batching: A review. European Journal of Operational Research 120, 228–249. Qi, X.L., Zhou, S.G., Yuan, J.J., 2009. Single machine parallel-batch scheduling with deteriorating jobs. Theoretical Computer Science 410, 830–836. Sahni, S., 1976. Algorithms for scheduling independent tasks. Journal of the Association for Computing Machinery 23, 116–127. Ventura, J.A., Kim, D., Garriga, F., 2002. Single machine earliness-tardiness scheduling with resource-dependent release dates. European Journal of Operational Research 142, 52–69. Webster, S.T., Baker, K.R., 1995. Scheduling groups of jobs on a single machine. Operations Research 43, 692–703. Wu, C.C., Lee, W.C., 2003. Scheduling linear deteriorating jobs to minimize makespan with an availability constraint on a single machine. Information Processing Letters 87, 89–93.