On scheduling an unbounded batch machine

On Scheduling an Unbounded Batch Machine

Zhaohui Liu

, Jinjiang Yuan

and T.C. Edwin Cheng

Shanghai 200237, People’s Republic of China 2_{Department of Mathematics, Zhengzhou University} Zhengzhou, Henan 450052, People’s Republic of China

3_{Department of Management, The Hong Kong Polytechnic University} Kowloon, Hong Kong SAR, People’s Republic of China

August 27, 2002

Abstract

A batch machine is a machine that can process up to_cjobs simultaneously as a batch, and the processing time of the batch is equalto the longest processing time of the jobs assigned to it. In this paper, we deal with the complexity of scheduling an un-bounded batch machine, i.e., _c = +∞. We prove that minimizing totaltardiness is binary NP-hard, which has been an open problem in the literature. Also, we establish the pseudopolynomial solvability of the unbounded batch machine scheduling problem with job release dates and any regular objective. This is distinct from the bounded batch machine and the classical single machine scheduling problems, most of which with different release dates are unary NP-hard. Combined with the existing results, this paper provides a nearly complete mapping of the complexity of scheduling an unbounded batch machine.

Keywords: Scheduling; Batch Processing; Complexity

∗_{Corresponding author.}

1

Introduction

A batch machine or batch processing machine is a machine that can process several jobs simultaneously as a batch, and the processing time of the batch is equal to the longest processing time of the jobs assigned to it. The research on batch machine scheduling is motivated by burn-in operations in semiconductor manufacturing (Lee et al. [8]). Potts and Kovalyov [11] review the existing results.

The problems that we study in this paper can be formulated as the following model. There are _n independent jobs _{J1, J2, . . . , Jn} to be scheduled on a batch ma-chine that can process up to _c jobs simultaneously, where _c is called the capacity of the batch machine. Each job _Jj (1 ≤ _j ≤ _n) is associated with a processing time

pj and a release date rj, before which the job cannot be scheduled. The

schedul-ing objective is to minimize a regular minsum function _fj = n_j=1fj(_Cj) or a regular minmax function _fmax = maxn_j=1fj(_Cj), where _fj is a nondecreasing func-tion of the complefunc-tion time _Cj of job _Jj. Among the popular regular objectives are

Cmax, Lmax,Cj,wjCj,Uj,wjUj,Tj andwjTj. Specifically, we focus on the

totaltardiness_Tj =n_j=1max{0_{, Cj}−_dj}, where_dj is given as the due date of job_Jj and max{0_{, Cj}−_dj}is the tardiness of job_Jj under a schedule. See Lawler et al. [6] for definitions of other objectives. As in Liu and Yu [10], the batch machine with capacity

c is denoted by _B(_c). In this paper, we restrict ourselves to the unbounded case, i.e.,

B(∞). Using the three-field notation, we denote the problems under consideration by

B(∞)|_rj|_fj, _B(∞)|_rj|_fmax, and so on.

Cheng et al. [4] prove that _B(∞)|_rj|_Lmax is NP-hard. In addition, they establish the polynomial solvability of a wide variety of special cases of_B(∞)|_rj|_fmax(including

rj = 0). It is shown in Brucker et al. [2] that B(∞)||Uj is polynomially solvable,

B(∞)||_wjUj and _B(∞)||_wjTj are NP-hard, and _B(∞)||_fj is pseudopolynomi-ally solvable. But it is open whether _B(∞)||_Tj is polynomially solvable or binary NP-hard. Concerning_B(∞)|_rj|_wjCj, Deng and Zhang [5] establish its NP-hardness and present polynomial algorithms for several special cases.

As to the bounded case,_B(_c)||_Cmax is solved by a simple method due to Bartholdi (Lee and Uzsoy [7]). Brucker et al. [2] prove that_B(2)||_Lmax(and hence_B(2)|_rj|_Cmax) is unary NP-hard. Baptiste [1] presents polynomial dynamic programming algorithms for problems _B(_c)|_{rj, pj} = _p|_F with _F ∈ {_wjCj,wjUj,Tj}. Li and Lee [9] solve_B(_c)|_rj|_Ujunder some agreeability assumption on job processing times, release dates and due dates. However, the complexity of_B(_c)||_Cjand_B(_c)||_wjCj remains open, but _B(_c)||_Cj can be solved in_O(_nc(c−1)) time ([2]).

This paper is organized as follows. In Section 2, we prove the binary NP-hardness of

In Section 3, we show the pseudopolynomial solvability of the problems_B(∞)|_rj|_fj and _B(∞)|_rj|_fmax. Finally, In Section 4, we present a summary of the complexity status of various unbounded batch machine scheduling problems.

2

NP-hardness of total tardiness problem

In this section, we establish the binary NP-hardness of the problem _B(∞)||_Tj by a reduction from the binary NP-complete PARTITION problem.

PARTITION Given _t positive integers _{a1, a2, . . . , at} with t_i=1ai = 2_B, decide if there exists a partition of the index set _I = {1_,2_{, . . . , t}} into two disjoint subsets _I1 and _I2 such that _i∈I1ai =_i∈I2ai =_B.

Given an instanceP of PARTITION, we first define 3_t+ 1 integers:

Mt = t i=1 (_t−_i)_ai+ 8_B Mk = 2 t i=k+1 Mi+ t i=1 (_t−_i)_ai + 8_B (_k=_t−1_{, t}−2_{, . . . ,}1) L1 = 7 t i=1Mi + t i=1 (_t−_i)_ai+ 4_B Lk = 2 k−1 i=1Li + 7 t i=1Mi + t i=1 (_t−_i)_ai+ 4_B (_k = 2_,3_{, . . . ,}2_t+ 1)_. Obviously, the integers are such that

2_{B Mt Mt−1} · · · _{M1 L1 L2} · · · _L2t+1. Now we define an instance Qof _B(∞)||_Tj as follows.

Q consists of 10_t+ 3 jobs that are classified into 2_t+ 1 types. Each type 2_k−1 (1 ≤ _k ≤ _t) contains five jobs: _J21_{k−1, J2}2_{k−1, J2}3_k−1 and two additionalcopies of _J21_k−1. Their processing times and due dates are given by

p1_2k−1 = _L2k−1 p22k−1 = L2k−1 +Mk p3_2k−1 = _L2k−1 + 2_Mk d1_2k−1 = 2 2k−2 i=1 Li + 5 k−1 i=1Mi +_L2k−1+_Mk+ 2_B d22k−1 = 2 2k−1 i=1 Li + 5 k−1 i=1Mi d3_2k−1 = 2 2k−1 i=1 Li + 5 t i=1Mi + 2_{B .}

Each type 2_k(1≤_k ≤_t) also contains five jobs: _J21_{k, J2}2_{k, J2}3_k and two additionalcopies of _J21_k. Their processing times and due dates are given by

p12k = L2k p2_2k = _L2k+_Mk+_ak p3_2k = _L2k+ 2_Mk d1_2k = 2 2k−1 i=1 Li + 5 k−1 i=1Mi +_L2k+ 3_Mk+ 2_B d22k = 2 2k i=1Li + 5 k−1 i=1Mi + 3_Mk−(_t−_k+ 1)_ak d3_2k = 2 2k i=1Li + 5 t i=1Mi + 2_{B .} Type 2_t+ 1 contains three copies of job_J21_t+1 with

p1_2t+1 = _L2t+1 d1_2t+1 = _L2t+1 + 2 2t i=1 Li + 5 t i=1 Mi+B .

Set the threshold value

T∗ = 2 t i=1 Mi+ t i=1 (_t−_i)_ai +_{B .}

We are asked to answer whether there exists a schedule _σ for instance Q such that

T(_σ)≤_T∗, where _T(_σ) denotes the totaltardiness of_σ.

Clearly, the construction of Q takes a polynomial time under the binary coding. In the remainder of this section, we will show that Q has a schedule _σ such that

T(_σ)≤_T∗ if and only if the PARTITION instance P has a solution {_{I1, I2}} such that

i∈I1ai =

i∈I2ai = B. Note that if putting the jobs in instance Q according to the

shortest processing time (SPT) rule, we obtain the sequence: (_J11_{, J1}2_{, J1}3_{, J2}1_{, J2}2_{, J2}3_{, . . . , J2}1_{t, J2}2_{t, J2}3_{t, J2}1_t+1)_.

Suppose that Q has a schedule _σ = (B_1,B_{2, . . . ,}B_m) such that _T(_σ) ≤ _T∗, where each B_i is a batch. Let _p(B_i) denote the processing time of batch B_i. It is reasonable to require that the processing time of each job in B_i+1 is larger than _p(B_i); otherwise, shifting the jobs in B_i+1 with processing times no larger than _p(B_i) to B_i does not increase _T(_σ). Then, _σ has the properties:

(i) the jobs in each B_i come from a contiguous segment of the SPT sequence, and allB_is are arranged in order of increasing _p(B_i);

(ii) for each _k (1≤_k≤2_t+ 1), al l _Jk1s are processed in a batch. Lemma 1 will give more explanations about the structure of _σ.

Lemma 1 _σ has the following further properties: (iii) each batch contains only jobs of one type;

(iv) for each_k(1≤_k ≤_t), the jobs of types2_k−1and2_kare divided into four batches:

{J21k−1, J22k−1}, {J23k−1}, {J21k}, {J22k, J23k} (Pattern 2112) with total processing

time2(_L2k−1+_L2k) + 5_Mk; or{_J21_k−1}, {_J22_{k−1, J2}3_k−1}, {_J21_{k, J2}2_k}, {_J23_k}(Pattern 1221) with total processing time 2(_L2k−1+_L2k) + 5_Mk+_ak.

Proof If property (iii) does not hold, there must exist some_k (1≤_k ≤2_t) such that

Jk3 and Jk1+1 are processed in a batch. But p1_k+1−d3_k = _Lk+1−2 k i=1Li− 5 t i=1Mi− 2_B = 2 t i=1Mi + t i=1 (_t−_i)_ai + 2_{B > T}∗_,

which implies the tardiness of _Jk3 is larger than_T∗, a contradiction to _T(_σ)≤_T∗. We prove property (iv) by induction. If the jobs of type 1 are processed in a batch, then the totaltardiness of three _J11s is equal to

3(_p3₁−_d1₁) = 3(_M1−2_B) = 2_M1+ 2 t i=2Mi + t i=1 (_t−_i)_ai+ 2_{B > T}∗_.

On the other hand, if _J11_{, J1}2 and _J13 are processed in three batches, then the tardiness of _J13 is 3 j=1p j 1−d31 > L1−5 t i=1Mi −2_{B > T}∗_.

Thus, _J11_{, J1}2 and _J13 must be processed in two batches: {_J11_{, J1}2}, {_J13}; or {_J11},

{J12, J13}. Further, noticing that the two batches of type 1 require at least 2L1 + 2M1

units of processing time, we can similarly prove that the jobs of type 2 are processed in two batches: {_J21_{, J2}2},{_J23}; or {_J21}, {_J22_{, J2}3}.

If batches{_J11_{, J1}2} and {_J21_{, J2}2} both exist, then the totaltardiness of three _J21s is 3(_p2₁+_p3₁+_p2₂−_d1₂)_>3(_M1−2_B)_{> T}∗_.

If both {_J12_{, J1}3} and {_J22_{, J2}3} exist, the totaltardiness of _J12 and _J22 is 2(_p1₁+_p3₁) +_p1₂+_p23−_d2₁−_d2_{2 >}3_{M1 > T}∗_.

So the four batches of types 1 and 2 must be: {_J11_{, J1}2}, {_J13}, {_J21}, {_J22_{, J2}3}; or {_J11},

{J₁2, J₁3}, {_J21_{, J2}2},{_J23}.

Suppose that the conclusion in property (iv) is true for each_i= 1_,2_{, . . . , k}−1. Then, the start time of the first batch of types 2_i−1 and 2_i is not less than 22_ji₌₁−2_Lj + 5i_j−₌₁1 _Mj. If the four batches of types 2_i−1 and 2_i are of Pattern 2112, then the tardiness of _J22_i is at least 2_Mi; if they are of Pattern 1221, then the tardiness of _J22_i−1 is at least 2_Mi. Therefore, the jobs of types 1_,2_{, . . . ,}2_k −2 have totaltardiness of at least 2k_i=1−1_Mi, which implies the jobs of types 2_k −1_,2_{k, . . . ,}2_t+ 1 have total tardiness of at most 2t_i=kMi +_it₌₁(_t−_i)_ai +_B. Noticing that the start time of the first batch of types 2_k−1 and 2_k will not be less than 2_i2₌₁k−2_Li+ 5k_i=1−1_Mi, we can prove by an analysis similar to that for types 1 and 2 that if property (iv) does not hold for _k, the jobs of types 2_k −1 and 2_k willhave totaltardiness larger than 2t_i=kMi+t_i=1(_t−_i)_ai+_B, which leads to a contradiction. ✷ Let_I1 be the set of indices _k (1≤_k ≤_t) such that the four batches of types 2_k−1 and 2_k are of Pattern 2112. Let _I2 = _I\_I1, where _I = {1_,2_{, . . . , t}}. A schedule with properties (i)-(iv) must contain 4_t+ 1 batches in the following form:

(B_4k−3,B_4k−2,B_4k−1,B_4k) =          {J₂1_k−1, J₂2_k−1},{J₂3_k−1},{J₂1_k},{J₂2_k, J₂3_k}, k∈I1 {J21k−1},{J22k−1, J23k−1},{J21k, J22k},{J23k} , k∈I2 B4t+1 = {J21t+1}.

The tardiness of each job of types 1_,2_{, . . . ,}2_t in the schedule is given by Lemma 2.

Lemma 2 For each _k ∈_I1, _J22_k is the only tardy job in B_4k−3, B_4k−2, B_4k−1 and B_4k, and its tardiness is

2_Mk+ (_t−_k+ 1)_ak+{_ai|_{i < k , i}∈_I2}_.

For each _k ∈ _I2, _J22_k−1 is the only tardy job in B_4k−3, B_4k−2, B_4k−1 and B_4k, and its tardiness is

2_Mk+{_ai|_{i < k , i}∈_I2}_.

Proof By property (iv), the totalprocessing time of batchesB_4k−3,B_4k−2,B_4k−1 and

B4k is 2(L2k−1+L2k) + 5Mk if k ∈ I1, or 2(L2k−1+L2k) + 5Mk+ak if k ∈ I2. Then

the start time of batch B_4k−3 is equalto

2 2k−2 i=1 Li + 5 k−1 i=1Mi +{_ai|_{i < k , i}∈_I2}_.

By computation, it is easy to verify that if _k ∈ _I1, B_4k−3, B_4k−2 and B_4k−1 contain no tardy jobs; if _k ∈ _I2, B_4k−3, B_4k−1 and B_4k contain no tardy jobs. For _k ∈ _I1, the completion time of B_4k ={_J22_{k, J2}3_k} is 2 2k i=1Li + 5 k i=1Mi +{_ai|_{i < k , i}∈_I2}_.

Thus, _J23_k is on-time and_J22_k has tardiness of 2_Mk+ (_t−_k+ 1)_ak+{_ai|_{i < k , i}∈_I2}. For _k∈_I2, the completion time of B_4k−2 ={_J22_{k−1, J2}3_k−1} is

2 2k−1 i=1 Li + 5 k−1 i=1Mi + 2_Mk+{_ai|_{i < k , i}∈_I2}_.

Thus, _J23_k−1 is on-time and _J22_k−1 has tardiness of 2_Mk+{_ai|_{i < k , i}∈_I2}. ✷

Lemma 3 Let _σ be a schedule with properties (i)-(iv). Then, _T(_σ) ≤ _T∗ if and only if _k∈I1ak =_k∈I2ak =_B.

Proof By Lemma 2, we have

T(_σ) = t k=1 2_Mk+{_ai|_{i < k , i}∈_I2} + k∈I1 (_t−_k+ 1)_ak+ 3 max   0, k∈I2 ak−B   ,

where the third term is the totaltardiness of three _J21_t+1s. Since

t k=1 {ai|i < k , i∈I2}= i∈I2 (_t−_i)_ai, it holds that T(_σ) = 2 t k=1Mk + t k=1 (_t−_k)_ak+ k∈I1 ak+ 3 max   0, k∈I2 ak−B   .

Then,_T(_σ)≤_T∗ if and only if_k∈I1ak≤_B and_k∈I1ak+ 3_k∈I2ak ≤4_B. Noticing that _k∈I1ak+_k∈I2ak = 2_B, we have compl eted the proof. ✷

We now prove the main result of this section.

Theorem 1 _B(∞)||_Tj is binary NP-hard.

Proof IfQhas a schedule _σ such that _T(_σ)≤_T∗, then we may require or prove that

σ possesses properties (i)-(iv). It follows from Lemma 3 that the PARTITION instance

P has a solution {_{I1, I2}}. Conversely, if the PARTITION instance P has a solution

{I1, I2}, we simply construct a schedule with properties (i)-(iv). It again follows from Lemma 3 that the constructed schedule has total tardiness no larger than _T∗. ✷

3

Pseudopolynomial solvability for problems with

job release dates and regular objectives

In this section, we develop a pseudopolynomial time algorithm for the general problems

B(∞)|_rj|_fj and _B(∞)|_rj|_fmax. The algorithm is based on the following observa-tion: there exists an optimal schedule in which if the longest job is started at time _t, then all the jobs released at or before_t should be started at or before_t and all the jobs released after _t should be started after _t.

Let _α and _γ be the job index sequences such that _rα(1) ≤ _rα(2) ≤ · · · ≤ _rα(n) and

pγ(1) ≤ pγ(2) ≤ · · · ≤ pγ(n), respectively. Let α(i, j) = {α(i), α(i+ 1),· · ·, α(j)} and γ(_{i, j}) ={_γ(_i)_{, γ}(_i+ 1)_,· · ·_{, γ}(_j)}. Let_J(_{i1, i2};_k) denote the subset of jobs with indices in _α(_{i1, i2})∩_γ(1_{, k}). Note that the number of such subsets is _O(_n3). The main idea of our algorithm is to schedule the jobs among _J(_{i1, i2};_k1)∪ {_Jγ(k2)} (_{k1 < k2}) into a given intervalsuch that_Jγ(k2) is completed at the end of the interval and the objective value of the subschedule is minimized.

To simplify the exposition, we introduce an auxiliary job_Jn+1 with _rn+1 =_rα(n)+

_n

j=1pj, pn+1 =pγ(n) and fn+1(t)≡ 0. It is easy to see that Jn+1 should be scheduled

at the end of an optimalschedule.

3.1

Problem

_B

(

∞

)

|

_r

|

_f

Let_F(_{i1, i2};_{k1, k2};_{x, y}) (_{k1 < k2}) denote the minimum objective value when scheduling the jobs among _J(_{i1, i2};_k1)∪ {_Jγ(k2)} into the interval[_{x, y}], subject to the constraint that _Jγ(k2) is completed at time _y. If _J(_{i1, i2};_k1) =∅, then

F(_{i1, i2};_{k1, k2};_{x, y}) =    fγ(k2) (_y)_, if max{_{rγ(k2), x}} ≤_y−_pγ(k2) +∞_, otherwise_.

Generally, _F(_{i1, i2};_{k1, k2};_{x, y}) can be computed recursively.

(i) If_γ(_k1)∈_α(_{i1, i2}), then_J(_{i1, i2};_k1) =_J(_{i1, i2};_k1−1) and we have

F(_{i1, i2};_{k1, k2};_{x, y}) =_F(_{i1, i2};_k1−1_{, k2};_{x, y})_.

(ii) If _γ(_k1) ∈ _α(_{i1, i2}) and _{rγ(k1) > y}−_pγ(k2), then _Jγ(k1) cannot be scheduled in [_{x, y}], and hence _F(_{i1, i2};_{k1, k2};_{x, y}) = +∞.

(iii) If_γ(_k1)∈_α(_{i1, i2}) and _rγ(k1) ≤_y−_pγ(k2), we have

F(_{i1, i2};_{k1, k2};_{x, y}) = min      F(_{i1, i2};_k1−1_{, k2};_{x, y}) +_fγ(k1)(_y) min max{rγ(k1), x}≤t≤y−pγ(k1)−pγ(k2) H(_t)     ,

where the first term is taken if _Jγ(k1) is processed in the batch including _Jγ(k2), and

H(_t) = _H1(_t) +_H2(_t) in the second term is taken if _Jγ(k1) is started at time_t. We al so note that the first term will not be taken when _k2 =_n+ 1, i.e., _Jn+1 will occupy the last batch alone.

H1(_t) is the contribution to_H(_t) of jobs processed in [_{x, t}+_pγ(k1)]. It is reasonable to assume that none of the jobs with release dates no more than _t in _J(_{i1, i2};_k1−1) is scheduled after the batch including _Jγ(k1) since they have processing times no more than _pγ(k1). Let _i2 (_i1 ≤_i2 ≤_i2) be the maximum index satisfying _rα(i

2)≤t. Then,

H1(_t) =_F(_{i1, i2};_k1−1_{, k1};_{x, t}+_pγ(k1))_.

H2(_t) is the contribution to_H(_t) of jobs processed in [_t+_{pγ(k1), y}]. It obviously holds that

H2(_t) = _F(_i2+ 1_{, i2};_k1−1_{, k2};_t+_{pγ(k1), y})_.

By computing _F(1_{, n};_{n, n} + 1;_{rα(1), rn+1} +_pn+1) recursively, we can obtain the optimalobjective value. An optimalschedule can be found by backtracking.

Now we analyse the complexity of the recursion. The size of the domain of function

F(_{i1, i2};_{k1, k2};_{x, y}) is _O(_n4_P2), where _P = _rα(n) +n_i=1pi. To obtain the vaule of each _F(_{i1, i2};_{k1, k2};_{x, y}), we need at most _O(_P) time (see cases (i)-(iii)). Thus, the complexity of the recursion is at most _O(_n4_P3), which is pseudopolynomial.

3.2

Problem

_B

(

∞

)

|

_r

|

_f

For the problem _B(∞)|_rj|_fmax, our analysis is similar to that for the problem

B(∞)|_rj|_fj except that in case (iii),

F(_{i1, i2};_{k1, k2};_{x, y}) = min      max_F(_{i1, i2};_k1−1_{, k2};_{x, y})_{, fγ(k1)}(_y) min max{rγ(k₁₎, x}≤t≤y−pγ(k₁₎−pγ(k₂₎H (_t)     , where _H(_t) = max{_H1(_t)_{, H2}(_t)}.

4

Complexity status of unbounded batch machine

problems

In this paper, we have addressed the complexity of scheduling an unbounded batch machine. Our results show that all problems with regular objectives are pseudopoly-nomially solvable even if the jobs have different release dates. This is distinct from the bounded batch machine and the classical single machine scheduling problems, most of which with different release dates are unary NP-hard.

Finally, we present a summary of the complexity status of various unbounded batch machine scheduling problems. Following Brucker and Knust [3], we use the terminol-ogy: maximal polynomially solvable, maximal pseudopolynomially solvable and mini-malNP-hard.

• maximal polynomially solvable:

B(∞)||_Uj (Brucker et al. [2])

B(∞)|_rj|_fmax with a fixed number of _rj or_pj (Cheng et al. [4])

B(∞)|_rj|_wjCj with a fixed number of _rj or_pj (Deng and Zhang [5])

• maximal pseudopolynomially solvable:

B(∞)|_rj|_fmax (this paper)

B(∞)|_rj|_fj (this paper)

• minimalNP-hard:

B(∞)||_Tj (this paper)

B(∞)||_wjUj (Brucker et al. [2])

B(∞)|_rj|_Lmax (Cheng et al. [4])

B(∞)|_rj|_wjCj (Deng and Zhang [5])

• Open:

B(∞)|_rj|_Cj

Acknowledgment

This research is supported in part by The Hong Kong Polytechnic University under grant number G-YW59. The first author is also supported by the National Natural Science Foundation of China under grant number 10101007.

References

[1] P. Baptiste, Batching identicaljobs, MathematicalMethods of Operations Re-search 52 (2000) 355–367.

[2] P. Brucker, A. Gladky, H. Hoogeveen, M.Y. Kovalyov, C.N. Potts, T. Tautenhahn, S.L. van de Velde, Scheduling a batching machine, Journal of Scheduling 1 (1998) 31–54.

[3] P. Brucker, S. Knust, Complexity results for scheduling problems, http://www.mathematik.uni-osnabrueck.de/research/OR/class/

[4] T.C.E. Cheng, Z. Liu, W. Yu, Scheduling jobs with release dates and deadlines on a batch processing machine, IIE Transactions 33 (2001) 685–690.

[5] X. Deng, Y. Zhang, Minimizing mean response time in batch processing system, Lecture Notes in Computer Science 1627 (1999) 231–240.

[6] E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, D.B. Shmoys, Sequencing and scheduling: algorithms and complexity, in Graves, S.C., Rinnooy Kan, A.H.G. and Zipkin, P.H. (eds.), Handbooks in Operations Research and Management Science, Volume 4, Logistics of Production and Inventory, North Holland, Amsterdam, 1993, 445–522.

[7] C.-Y. Lee, R. Uzsoy, Minimizing makespan on a single batch processing machine with dynamic job arrivals, International Journal of Production Research 37 (1999) 219–236.

[8] C.-Y. Lee, R. Uzsoy, L.A. Martin-Vega, Efficient algorithms for scheduling semi-conductor burn-in operations, Operations Research 40 (1992) 764–775.

[9] C.-L. Li, C.-Y. Lee, Scheduling with agreeable release times and due dates on a batch processing machine, European Journalof OperationalResearch 96 (1997) 564–569.

[10] Z. Liu, W. Yu, Scheduling one batch processor subject to job release dates, Discrete Applied Mathematics 105 (2000) 129–136.

[11] C.N. Potts, M.Y. Kovalyov, Scheduling with batching: a review, European Journal of OperationalResearch 120 (2000) 228–249.