Two-stage hybrid flow shop scheduling with dynamic job arrivals

Computers & Operations Research 39 (2012) 1701–1712

Contents lists available at SciVerse ScienceDirect

Computers & Operations Research journal homepage: www.elsevier.com/locate/caor

Two-stage hybrid flow shop scheduling with dynamic job arrivals Frank S. Yao a,n, Mei Zhao b, Hui Zhang c a b c

CUHK Business School, Chinese University of Hong Kong, Hong Kong, China Department of Mathematics, Hong Kong University of Science and Technology, Hong Kong, China Production Planning Division, Grace Manufacturing Corporation, Shanghai, China

a r t i c l e i n f o

abstract

Available online 18 October 2011

Motivated by applications in semiconductor manufacturing industry, we consider a two-stage hybrid flow shop where a discrete machine is followed by a batching machine. In this paper, we analyze the computational complexity of a class of two-machine problems with dynamic job arrivals. For the problems belonging to P we present polynomial algorithms. For the NP-complete problems we propose the heuristics, and then establish the upper bounds on the worst case performance ratios of the heuristics. In addition, we give the improved heuristics that can achieve better performances. & 2011 Elsevier Ltd. All rights reserved.

Keywords: Batch scheduling Dynamic programming Heuristics

1. Introduction

paper we consider the problem with the system configuration bd. b is the capacity of the batching machine. In other words, each

In wafer fabrications, the processing stage of diffusion is one of the most important stages. Scheduling of this stage has a great effect on the system performances. There are two types of machines, i.e., batching machines and discrete machines. Diffusion and oxidation operations are performed by batching machines, while laser ablation, inspection and repair operations are performed by discrete machines [1–3]. As for semiconductor manufacturers, there are two process requirements that should be considered in diffusion stages. First, jobs are categorized into different job families, and only jobs in the same family can be processed on batching machines simultaneously. Second, there exists limited waiting time between two tandem machines. For instance, the waiting time after the operations in furnace tubes is limited in order to prevent the absorption of the particulates in air. In most cases, both requirements mentioned above should be met at the same time. However, in some steps, it may be the case that limited waiting time constraints are not considered. The intent of this paper is to deal with the scheduling problems in which a discrete machine is followed by a batching machine. Jobs in the same family are assumed to be the same processing times on the two machines. Only jobs in the same family can be processed on batching machines simultaneously. The situation where the unequal ready times are allowed at the first machine is taken into consideration. Preemption is not allowed on the two machines. Problems with/without limited waiting time constraints are studied. Referring to Ref. [2], let b be a batching machine, and d be a discrete machine. Denote by - the system configuration. In this

batch cannot contain more than b jobs. To reduce the throughput time, the makespan criterion is adopted in this paper. We summarize the problems of interest as follows:

n

Corresponding author. E-mail address: [email protected] (F.S. Yao).

0305-0548/$ - see front matter & 2011 Elsevier Ltd. All rights reserved. doi:10.1016/j.cor.2011.10.006

(1) (2) (3) (4)

F2/b-d, F2/b-d, F2/b-d, F2/b-d,

r j, r j, r j, r j,

bon, bon, bon, bon,

pk1 ¼p1, pk2 ¼p2/Cmax incompat/Cmax pk1 ¼p1, pk2 ¼p2, qk ¼ q/Cmax qk, incompat/Cmax

As we can see, problems (1) and (3) with single job family considered are the special cases of problems (2) and (4), respectively. Moreover, problems (1) and (2) can be, respectively, reduced to problems (3) and (4) when qk ¼ þN for all kA{1,y,K}. We will show that there are polynomial procedures for problems (1) and (3). Problems (2) and (4) belong to NP-complete in strong sense. Hence we propose some heuristics for these problems. The organization of this paper is as follows. Section 2 briefly reviews related literature. In Section 3, we introduce some basic notations used later. Section 4 discusses problems (1) and (2). In Section 5, problems with limited waiting time constraints are considered. Finally, we present our conclusions in the last section.

2. Related work In general (hybrid) flow shop problems refer to scheduling problems with one (multiple) machine(s) at each stage. Previous studies on this kind of problems have yielded fruitful results. Readers could refer to Refs.[4,5] for the more details. In this section, we briefly review the literature highly related to the problems we focus.

1702

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

With respect to batching machines, there are two kinds of batch modes. The first one is that the processing time of a batch is given by the maximum processing time of all jobs in the batch. This batch mode commonly exists in the back-end operations. Under this batch mode, Lee and Uzsoy [6] consider the problem of minimizing makespan in the presence of dynamic job arrivals. The other one is the batch mode with incompatible job families. That is, jobs from different families cannot be processed together. This type of batch processing mainly exists in front-end operations. In this paper, the batching machine refers to the machine under the second batch mode. Several of dynamic scheduling algorithms for minimizing total waiting time have been developed by Fowler et al. [7,8], Weng and Leachman [9], Robinson et al. [10], and so forth. A review of literature shows that it is Uzsoy who first systematically studied the batch scheduling problems with incompatible job families. He divided them into problems with equal ready times and problems with dynamic job arrivals, and provided numerous algorithms to solve them optimally or heuristically [11]. Among them, the TSEDD (Timesymmetric EDD) algorithm will be used to tackle the NP-complete problem in this paper. So we briefly introduce it here. The TSEDD algorithm which minimizes makespan on a batching machine with dynamic job arrivals just has four steps. First, all jobs are sequenced in non-increasing order of their ready times; second, for each family, starting from the first job we form full batch greedily; third, these batches are sequenced in the descending order of their ready times; finally, we schedule each batch to start as early as possible. Uzsoy has proved that the TSEDD algorithm works correctly and finds an optimum solution in polynomial time. In this paper, we will use the above TSEDD algorithm or its modified version as the first step of our heuristics. Flow shop problems with at least one batching machine are studied recently. Ahmadi et al. [12] first investigate two-stage flow shop problems with batching and discrete machines. Two system P configurations (b-d and d-b) and two objectives (Cmax and Cj) are considered in their paper. Sung et al. [13] study the multistage flow shop of batching machines and give a decomposition approach to solve it efficiently. Cheng and Wang [14] consider the same configuration except that the processing time of a batch is defined as the total processing time of the jobs contained in the batch. Wang et al. [15] consider the two-stage flow shop of batching machines with multiple job families. However, jobs they consider have equal ready times. Sung and Kim [3] study the scheduling problem with the system configuration (d-b) and dynamic job arrivals allowed in their paper. They prove that the problem considered belongs to NP-complete in strong sense. There are few papers that address flow shop problems with limited waiting time constraints. Yang and Chern [16] prove that the two-stage flow shop problem with limited waiting time constraints belongs to NP-complete. Joo and Kim [17] develop a branch-and-bound procedure for the above problem. Su [1] proposes a two-phase heuristic algorithm for a two-stage flow shop problem with limited waiting time constraints and the system configuration b-d. However, the above papers do not consider the situation where unequal ready times are allowed at the first machine as well. Others scheduling problems with specific process requirements, such as non-identical job sizes [18,19], no waiting time constraints [20,21], maintenance constraints [22], limited buffer storage [23], and transportation and deterioration [24], are also considered by many researchers.

needed. We denote by K the number of families, k the family index, and nk the job set of family k. Jik denote the ith job of family k and rik is the ready time of Jik. pk1 is the processing time of family k on the batching machine while pk2 is the processing time of family k on the discrete machine. b is the capacity of the batching machine. We denote by qk the limited waiting time for family k. Let Uk(t1,t2) be the number of jobs in family k whose release date is in the interval (t1,t2]. Without loss of generality, we assumes that rik Zri0 k if iZi0 . When we consider one job family problems (Sections 4.1 and 5.1), rik, pk1, pk2, nk, Uk(t1,t2) and qk, are simplified into rj, p1, p2, n, U(t1,t2) and q, respectively. Without loss of generality, we may assume that bonk; otherwise b: ¼n. 4. Problems without limited waiting time constraints In this section, we consider problems (1) and (2). At first, the problem with one job family is investigated in Section 4.1. Next, the problem with multiple job families will be handled. 4.1. F2/b-d, rj, bon, pk1 ¼p1, pk2 ¼p2/Cmax The first theorem states the optimal starting times on the batching machine as well as the property of consecutive batches: Theorem 1. There exists an optimal schedule such that the time points at which a batch starts on the batching machine belong to T1: ¼{t9t ¼rj þl1p1,(rj,(l1A{0,1,y,n  1}}. Moreover, each time that a group of consecutive batches begins processing is equal to a job ready time, and jobs are batched as fully as possible at each potential batching instant. Proof. See property 13 in Ref. [25].

&

Theorem 2 shows the possible starting times on the discrete machine. Theorem 2. There exists an optimal schedule such that the time points at which a job starts and completes on the discrete machine belong to T 2 :¼ ft9t ¼ r j þ l1 p1 þ l2 p2 ,(r j ,(l1 A f1,. . .,ng,(l2 A f0,. . .,ngg: Proof. We first prove that the time points at which the mth job in the sequence of jobs on the discrete machine starts belong to T m 2 :¼ ft9t ¼ r j þ l1 p1 þ l2 p2 ,(r j ,(l1 A f1,. . .,mg,(l2 A f0,. . .,m1gg. We use induction on m. The case m¼ 1 is trivial. Let tm. be the starting time the m job. If the ready time of the (mþ1)th job for the discrete machine is less than or equal to the completion time of the mth job, then its optimal starting time is tm þp2. On the other hand, if the ready time of the (mþ1)th job for the discrete machine is greater than the completion time of the mth job. Based on Theorem 1, the optimal starting time of the (mþ1)th job must belong to {t9t¼ rj þl1p1,(rj,(l1A{1,y,mþ1}}. According to the induction hypothesis, the starting time of the (mþ1)th job on the discrete machine þ1 belongs to T m . This completes the induction step. Observe that 2 m1 m T 2 D T 2 for m¼2, 3,y, n. Hence let m¼n, and then we complete the proof. & According to Theorems 1 and 2, we can easily obtain the expression for the direct workload of the discrete machine at each job arrival. Theorem 3. There exists an optimal schedule such that the direct workload of the discrete machine at time rj belongs to

3. Notations Some basic notations used throughout this paper are given in this section while other definitions will be given later when

T 3 :¼ ft9t ¼ r j0 r j þl1 p1 þl2 p2 ,(r j0 ,(l1 A f1,. . .,ng,(l2 A f0,. . .,ngg [f0g: &

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Then the state variables of the DP algorithm are defined as ðr j ,n1 ,wÞ, where rj is the starting time of a consecutive batching process, and nj be the number of jobs in front of the batching machine at time rj, and w is the direct workload of the discrete machine at time rj. We denote by f(rj,n1,w) the minimum makespan of the unscheduled jobs at the state ðr j ,n1 ,wÞ. Then the DP recursion is ( f ðr j ,n1 ,wÞ ¼ minh tnðrj þ hp1 Þ r j þf

r nðrj þ hp1 Þ ,g 1 ðr j ,n1 ,hÞ þ Uðr j þ hp1 ,r nðrj þ hp1 Þ Þ, maxðg 2 ðr j ,n1 ,w,hÞtnðrj þ hp1 Þ þr j þhp1 ,0Þ

!) ,

ð1Þ where nðtÞ ¼ minfj9r j 4t, j ¼ 1,. . .,n þ 1g,with r n þ 1 ¼ þ 1: (

tnðrj þ hp1 Þ ¼

r j þ hp1 ,

if nðr j þ hp1 Þ ¼ n þ1

r nðrj þ hp1 Þ ,

otherwise

:

g1(rj,n1,h) is the number of jobs in front of the batching machine after a group of h consecutive batches that starts at time rj complete. It can be computed by the recursive equation as follows: g 1 ðr j ,n1 ,hÞ ¼ g 1 ðr j ,n1 ,h1Þ þ Uðr j þðh1Þp1 ,r j þ hp1 Þ minfg 1 ðr j ,n1 ,h1Þ,bg, with g 1 ðr j ,n1 ,0Þ ¼ n1 : g2(rj,n1,w,h) is the direct workload of the discrete machine after a group of h consecutive batches that starts at time rj. complete. Similarly, the recursive equation is as follows: g 2 ðr j ,n1 ,w,hÞ ¼ minfg 2 ðr j ,n1 ,w,h1Þp1 ,0g þ minfg 1 ðr j ,n1 ,h1Þ,bg, with g 2 ðr j ,n1 ,w,0Þ ¼ w: The boundary condition for the DP recursion (1) is ( þ1, if a 40 f ðr n þ 1 ,a,bÞ :¼ : b, otherwise Then optimal solution can be found by calculating f ðr 1 ,1,0Þ. Based on the recursive formula (1), we have the following property: Property 1. The time complexity of the above DP algorithm is O(n6). Proof. According to Theorem 3, given rj, the space needed for all possible workload is O(n3). Hence, the total number of states cannot exceed O(n5). The computational effort for each state is at worst linear in number of jobs n. So the DP algorithm can be implemented to run in O(n6) time. & Next, we discuss an efficient optimal procedure for a special case, i.e., p1 op2. The following theorem gives us its optimal batch structure. Theorem 4. If p1 op2, there exists an optimal schedule such that each batch processed on the batching machine only contains one job. Proof. Suppose that there is a batch that contains more than one job. We can easily construct another sequence of batches containing only one job such that the makespan of the schedule never increases. &

1703

4.2. F2/b-d, rj, bon, incompat/Cmax In this subsection multiple job families with incompatibility on the batching machine are considered. The problem F2/b-d, rj, bon, incompat/Cmax belongs to NP-complete in strong sense bend on reductions to the known NP-complete problem in strong sense: F2/rj/Cmax. However, this problem is not the minimal NPcomplete problem. The following theorem shows that the problem even when restricted to instances where all jobs have unit processing times on the discrete machine also belongs to NPcomplete in strong sense. Theorem 5. The problem F2/b-d, rj, bon, pk2 ¼1, incompat/Cmax is strongly NP-complete. Proof. The proof is by reduction from the two-stage flow shop problem with dynamic arrivals F2/rj/Cmax. Given an instance of F2/rj/Cmax, we create an instance of F2/b-d, rj, bon, pk2 ¼1, incompat/Cmax in pseudo-polynomial time as follows. Let n be the number of jobs in F2/rj/Cmax. pk1 and pk2 (k¼1,y,n) are the processing times in stage 1 and stage 2, respectively. rk is the ready time of job k. Denote by b¼maxk{pk2} the capacity of the batching machine. For each job k, we create pk2 jobs and set these jobs as family k with the processing time pk1 on the batching machine, and the unit processing time on the discrete machine. In addition, we set rjk ¼rk for j¼1,y,pk2 and k¼1,y,n. Consider the decision problem of determining whether a schedule with C max rL exists for F2/rj/Cmax, where L is a positive integer. If such a schedule exists for F2/rj/Cmax, then a schedule with the same makespan for the batch scheduling problem also exists, where jobs from the same family are processed within a batch and the sequence of the batches corresponds to the sequence of the jobs in the schedule for F2/rj/Cmax. Similarly, if a schedule with Cmax rL exists for the batch scheduling problem, a schedule with the same makespan can be constructed. This completes the proof. & Since the scheduling problem F2/b-d, rj, bon, incompat/Cmax is strongly NP-complete, it is impossible to find a polynomial algorithm unless P¼NP. Hence, we present simple heuristic at first. A simple idea is to optimize the schedule in each stage independently. Note that Uzsoy [11] has proved that the TSEDD algorithm can obtain the minimum makespan for stage 1. Also, it is easy to prove that the FIFO policy is always the optimal schedule for stage 2 (so we assume that the FIFO rule is always applied on the discrete machine in this subsection). Hence we construct the heuristic by applying the TSEDD algorithm stage 1 and the FIFO policy in stage 2, respectively. This heuristic is called the TSEDD-FIFO heuristic. Next, we give a tight upper bound on the worst-case performance ratio of the TSEDD-FIFO heuristic.

Based on Theorem 4, the optimal algorithm for this case can be easily constructed as follows:

Property 2. The worst-case performance ratio of the TSEDD-FIFO algorithm is less than or equal to 2.

Step 1. Sequence jobs in increasing order of the ready time rj. Step 2. Schedule each job according to the sequence. The starting time of the jth job is given by max{rj,Cj  1}, where Cj  1 is the completion time of the (j  1)th job on the batching machine.

Proof. Let C nmax be the minimum makespan of the proposed problem, and C H max be the makespan achieved by the TSEDD-FIFO heuristic. Clearly, we have

Then we have the following property: Property 2. The time complexity of the above procedures is O(n log n). &

X

nk pk2 r C nmax and C 1max r C nmax ,

k

where C 1max is the completion time of the last batch on the batching machine achieved by the TSEDD algorithm.

1704

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Then we obtain 1 CH max rC max þ

X

Table 2 Data of Example 2.

nk pk2 r2C nmax :

k

n Therefore, we have ðC H max =C max Þ r 2. & The following examples illustrate that the worst-case performance ratio reached is near 2.

Example 1. Let K ¼2, b¼1,nk ¼ 1, and the processing times of jobs are given in Table 1 (T is a large positive integer). Applying the TSEDD-FIFO heuristic, we have C H max ¼ 2T þ 1, while the minimum makespan C nmax for this example is Tþ3 (see Fig. 1). Hence

Jobs

r ik

pk1

pk2

J11 J12 J13

0 1 2

4 T 1

1 1 T

β

δ

CH 2T þ 1 max -2, as T- þ 1: ¼ T þ2 C nmax

Example 2. Let K ¼3, b ¼1, nk ¼1, and the processing times of jobs are given in Table 2 (T is a large positive integer). Applying the TSEDD-FIFO heuristic, we have C H max ¼ 2T þ 5, while the minimum makespan C nmax for this example is Tþ6

β

δ

Table 1 Data of Example 1. Jobs

r ik

pk1

pk2

J11 J21

0 1

T 1

1 T

Fig. 2. Two schedules of Example 2: (a) the schedule given by the TSEDD-FIFO heuristic and (b) the optimal schedule.

(see Fig. 2). Hence CH 2T þ5 max -2, as T- þ1: ¼ T þ6 C nmax

β δ

β δ

Example 3. Let K ¼2, b¼T, and the processing time and arrival times of jobs are illustrated in Table 3. Applying the TSEDD-FIFO heuristic, we have C H max ¼ 2T þ2, while the minimum makespan C nmax for this example is Tþ3 (see Fig. 3). Hence CH 2T þ2 max -2, as T- þ1: ¼ T þ3 C nmax As we see from the above examples, the TSEDD-FIFO heuristic does not perform well. In what follows we design a more efficient heuristic by modifying the schedule created by the TSEDD-FIFO heuristic. First, we give some auxiliary notations. Let 9B9 be the number of batches in the sequence of batches, and B[j] be the batch in position j in the sequence of batches. k[j] is the function that returns the family index of B[j]. r[j] and n[j] are the ready time of the last job in B[j] and the batch size of B[j], respectively. We assume that r[9B9 þ 1]: ¼ þN. Let t 1½1 ,. . .,t 1½9B9 be the starting times of B[1],yB[9B9] on the batching machine, respectively. C 1½j is the completion time of B[j] on the batching machine. Easily, we have C 1½j ¼ t 1½j þpk½j 1 with C 1½0 :¼ 0, j ¼1,2,y,9B9. In this problem, we note that there exists an optimal schedule

Fig. 1. Two schedules of Example 1: (a) the schedule given by the TSEDD-FIFO heuristic and (b) the optimal schedule.

such that t 1½j ¼ maxfC 1½j1 ,r ½j g, j¼1,2,y,9B9. As for the discrete machine, we denote by t 2½1 ,. . .,t 2½9B9 the starting times of the first

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

1705 2

2

C4 : t 2½j þ 1 þ n½j þ 1 pk½j þ 1 2 Zt ½j þ 1 þn½j pk½j 2 , where t ½j þ 1 is the

Table 3 Data of Example 3. k

Nk

r ik

pk1

pk2

1 2

Tþ 1 1

0 1

1 T

1 1

β

δ

starting time of the first job in the (j þ1)th batch on the discrete machine when B[j] and B[j þ 1] are interchanged, then it is sufficient for the schedule to interchange B[j] and B[j þ 1]. Proof. It can be easily proved by a pair-wise batch interchange argument. & Based on Theorems 6–8, we develop an improved heuristic as follows: Heuristic 1 Step 1 Step 2 Step 3

β

Step 4 Step 5

δ Step 6 Fig. 3. Two schedules of Example 3: (a) the schedule given by the TSEDD-FIFO heuristic and (b) the optimal schedule.

jobs in B[1],y,B[9B9] on the discrete machine, respectively. We have t 2½j ¼ maxft 2½j1 þn½j1 pk½j1 2 ,C 1½j g with t 2½0 :¼ 0, j ¼1,2,y,9B9. Based on the above examples, the following three dominance properties are developed. Theorem 6. The makespan will never increase by batching the jobs as fully as possible at each scheduling instant. Proof. It can be directly proved by moving the jobs from the latter batch to the former one. & Theorem 7. If any h consecutive batches B[j],y,B[j þ h] satisfy the following conditions: C1 : maxfr ½j ,C 1½j1 g ¼ maxfr ½j þ 1 , C 1½j1 g ¼ . . . ¼ maxfr ½j þ h , C 1½j1 g, and C2 : maxfr ½j þ h þ 1 ,C 1½j1 g 4maxfr ½j ,C 1½j1 g, where jþh r9B9, then it is sufficient for the schedule to regard B[j],y,B[j þ h] as artificial jobs, and sort them by Johnson’s rule. Proof. Suppose that the above two conditions are satisfied. We can define an artificial job with zero processing time in stage 1 and p0 processing time in stage 2 where p0 is the remaining processing time on the discrete machine at time maxfr ½j ,C 1½j1 g. According to Johnson’s rule, this artificial job will be processed first. Moreover, it is easy to prove that the completion times of a group of h consecutive batches on both the two machines will never increase if we sort them by Johnson’s rule. This completes the proof. & Theorem 8. If any two adjacent batches B[j] and B[j þ 1] satisfy the following conditions: C1: k[j] ak[j þ 1], C2 : maxfC 1½j1 ,r ½j g or ½j þ 1 o C 1½j , C3 : r ½j þ 1 þpk½j þ 1 1 þpk½j 1 rr ½j þ 2 , and

Create a schedule by the TSEDD-FIFO heuristic. Check each batch in the schedule from B[1] to B[9B9], and let each batch be as full as possible (Theorem 6). Check the consecutive batches in the schedule to find out whether both two conditions in Theorem 7 are satisfied. If so, use Johnson’s rule to sequence these batches and go to Step 4; otherwise go to Step 5. Check each batch in the schedule from B[1] to B[9B9], and let each batch be as full as possible (Theorem 6). Check the adjacent batches in the sequence of batches to find out whether the four conditions in Theorem 8 are satisfied. If so, interchange the adjacent batches. Check each batch in the schedule from B[1] to B[9B9], and let each batch be as full as possible (Theorem 6).

Immediately we have the following property: Property 3. The worst-case performance ratio of Heuristic 1 is less than or equal to 2. For any instance, the makespan obtained by Heuristic 1 is less than or equal to that obtained by the TSEDD-FIFO heuristic. Proof. Observe that the makespan will never increase by steps 2– 6. This follows the correctness of the theorem. & Remark 1. It can be easily verified that Heuristic 1 reaches the optimal schedules for Examples 1–3. To evaluate the solution qualities of the two heuristics, we now develop the lower bounds. The first lower bound LB1 is derived from minimizing the makespan for each stage. As for the batching machine we have LB1 ðbÞ :¼ C 1max þ mink pk2 . Recall that C 1max is the minimum completion time of the last batch on the batching machine. As for the þ p1 þ p1 discrete machine we have LB1 ðdÞ ¼ C rmax , where C rmax is the minimum makespan of scheduling on the discrete machine with rik: ¼rik þpk1. Observe that the full batching strategy and Johnson’s rule can obtain the optimal schedule if jobs have the same ready times [2]. Hence the second type of lower bound LB2 is defined as the minimum completion time of the problem when the ready time of each job is equal to mini,krik. Then the overall lower bound can be derived as LB ¼ maxfLB1 ðbÞ,LB1 ðdÞ,LB2 g: 4.3. Computational results The computational experiments are conducted to evaluate our proposed TSEDD-FIFO heuristic and Heuristic 1. For the experiments, the following parameters are considered to generate the test problems: number of families 9K9: 5 and 10;

1706

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

number of jobs in each family nk: 20, 40, 60, and 80; capacity of the batching machine b: 4 and 6; range y: 0.25, 0.5, 1, 1.5, and 2 for  P  X k nk pk1 , n p ; r ik  U 1, y max k k2 k b

indicates that the number of jobs in each batch cannot larger than min(b(qk þ pk2/pk2)c,b). On the other hand, it can be proved that when (and if) a batch of family k contains minððqk þ pk2 =pk2 Þ,bÞ, the appropriate setting of the starting time of this batch will not violate the limited waiting time constraint. &

processing times on the batching machine pk1 are generated from 20 to 100 with uniform distribution; processing times on the discrete machine pk2 are generated from 4 to 20 with uniform distribution.

In what follows we say jobs in family k are fully batched if its batch size is minðbðqk þ pk2 =pk2 Þc,bÞ. Like Section 4, the problem with one job family is investigated in Section 5.1. In Section 5.2 the multiple job families with incompatibility are studied.

For each combination of the parameters, 100 problem instances are generated and solved, and their computational results are reported in average value (see Appendix A). From Tables A1–A5, Heuristic 1 performs reasonably well. The average value of Heuristic 1/LB is equal to 1.021, while the average value of TSEDD-FIFO/LB is equal to 1.029. Moreover, we observe that the TSEDD-FIFO heuristic cannot perform well when b is 6 and nk belongs to {20,40,80}. But, Heuristic 1 can improve the performances for those instances remarkably. We interpret this observation as follows: since 20, 40, and 80 are not dividable by 6, the number of jobs in the first batch of each family will be, respectively, 2, 4, and 2 by applying the TSEDD algorithm. As shown in Example 3, the makespan obtained by the TSEDD-FIFO heuristic will inevitably increase. On the other hand, step 2, step 4, and step 6 in Heuristic 1 try to fill the batches as fully as possible from B[1] to B[9B9]. Hence, Heuristic 1 can obtain the better results in these instances reasonably. Fig. 4 shows that the average performance ratio achieved by Heuristic 1 is much less than that achieved by the TSEDD-FIFO heuristic when y is small. When y is large, the performance ratio of two heuristics are both quite small. The reason is that since jobs are bunched up when y is a small, step 3 and step 5 of Heuristic 1 (see Examples 1 and 2) can take effect to reduce the makespan.

5. Problems with limited waiting time constraints In this section, we discuss the problems where the waiting time for stage 2 cannot be greater than a given bound. First, we give a property of the maximum batch size for each family. Theorem 9. The maximum batch size for family k is min(b(qk þpk2)/ pk2c),b). Proof. As for family k, the total processing time of jobs in a batch on the discrete machine should be less than or equal to qk þpk2; otherwise, the limited waiting time constraint will be violated. It 1.04 Heurstic 1/LB TSEDD-FIFO/LB

performance ratio

1.035 1.03 1.025 1.02 1.015 1.01 1.005

0.2

5

0.5

1

1.5

2

range Fig. 4. Performance ratios of TSEDD-FIFO and Heuristic 1 with different range values.

5.1. F2/b-d,rj,b on, pk1 ¼ p1, pk2 ¼p2, qk ¼q/Cmax We first give the general optimal procedures. Then we develop an efficient optimal procedure for problem with p2 4p1. The following theorem shows the time points at which a job starts on the discrete machine. Theorem 10. There exists an optimal schedule such that the time points at which a job starts on the discrete machine belong to T 2 ¼ ft9t ¼ r j þl1 p1 þ l2 p2 l3 q,(r j ,(l1 A f1,. . .,ng, (l2 ,l3 A f0,. . .,n1gg: Proof:. Like the proof of Theorem 8, we first prove that the time points at which the mth job in the sequence of jobs on the discrete machine starts belong to T m 2 :¼ ft9t ¼ r j þ l1 p1 þ l2 p2  l3 q,(r j ,(l1 A f1,. . .,mg,(l2 ,l3 A f0,. . .,m1gg. We use induction on m. The case m¼1 is trivial. Let tm denote the starting time of the mth job. If the ready time of the (m þ1)th job for the discrete machine is less than or equal to the completion time of the mth job, then its optimal starting time is tm þp2. If the ready time of the (m þ1)th job on the discrete machine is greater than the completion time of the mth job, we discuss the following two possibilities: Case 1. The starting time of the batch that contains the (m þ1)th job is larger than the completion time of its previous one. In this case, the limited waiting time constraint does not delay the starting times of the jobs on the discrete machine. Hence the optimal starting time of the (m þ1)th job on the discrete machine þ1 belongs to {rj þp1}j Z m þ 1. Obviously, fr j þ p1 gj Z m þ 1 DT m . 2 Case 2. The starting time of the batch that contains the (m þ1)th job is equal to the completion time of its previous batch. Let Bf be the first batch of a group of the consecutive batches that contains the mth job. There are two possibilities of the starting time of Bf. The first possibility is that the starting time of Bf is equal to the ready time of the last job in Bf. It indicates that the starting time of the (m þ1)th job on the batching machine belongs to {rj0 þl1p1}j0 o m þ 1, where l1A{1,y,m}. In this sub-case, the starting þ1 time of the (mþ1)th job on the discrete machine belongs to T m . 2 The other possibility is that the starting time of Bf on the batching machine is postponed in order to satisfy the limited waiting time constraint. Let Cf be the completion time of Bf and C0 the completion time of the batch that contains the (m þ1)th job. Note 0 0 that C 0 ¼ C f þ l1 p1 , where l1 A f1,. . .,mg. We can verify that the direct workload of discrete machine at time Cf is qþp2. According 0 m þ 2l1 to the induction hypothesis, we have C f þ p1 þ q A T 2 . Hence m þ 2l01 the starting time of the (m þ1)th 0 job belongs to T 2 qþ m þ 2l1 0 0 þ1 ðl1 1Þp1 . Obviously, we have T 2 qþ ðl1 1Þp1 D T m . 2 D Tm This completes the induction step. Observe that T m1 2 2, m¼2,y,n. Hence let m¼n, and then we complete the proof. & Now we can obtain the optimal time points which a batch starts on the batching machine.

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Theorem 11. There exists an optimal schedule such that each time that a group of consecutive batches begins processing belongs to

computed as follows: g 3 ðt 1 ,n1 ,w,h1 Þ ¼ g 3 ðt 1 ,n1 ,w,h1 1Þ þ Uðt 1 þ ðh1 1Þp1 ,t 1 þ h1 p1 Þ

T 1 ¼ ft9t ¼ r j þ l1 p1 þ l2 p2 l3 q,(r j ,(l1 A f0,1,. . .,ng,(l2 A f0,1,. . .,ng,(l3 A f0,. . .,ngg:

Proof. In consideration of the starting time of a group of consecutive batches, there are two possibilities:

1707

b1 ðt 1 ,n1 ,w,h1 Þ,

with

g 3 ðt 1 ,n1 ,w,0Þ ¼ n1 :

g 4 ðt 1 ,n1 ,w,h1 Þ ¼ maxðg 4 ðt 1 ,n1 ,w,h1 1Þp1 ,0Þ þb1 ðt 1 ,n1 ,w,h1 Þp2 , with g 4 ðt 1 ,n1 ,w,0Þ ¼ w,

Case 1. The starting time of a group of consecutive batches is equal to the ready time of the last job in the first batch. It means that its starting time belongs to {rj}j Z 1. Then the starting time of a group of consecutive batches belongs to T1. Case 2. The starting time of a group of consecutive batches is larger than the ready time of the last job in the first batch. It indicates that the limited waiting time constraint causes the delay of the first batch. Suppose that the index of the last job in this batch is m. According to the proof of Theorem 10, the starting

where   q þp2 maxðg 4 ðt 1 ,n1 ,w,h1 1Þp1 ,0Þ b1 ðt 1 ,n1 ,w,h1 Þ ¼ min , p2  g 3 ðt 1 ,n1 ,w,h1 1Þ þ Uðt 1 þ ðh1 1Þp1 ,t 1 þh1 p1 Þ,b : d e(t1 þ h1p1,h2) is the delay time of the next batch containing h 2 jobs after a group of h 1 consecutive batches which starts at time t 1 complete. It can be computed as

8 !    > g 4 ðt 1 ,n1 ,w,h1 Þ > < h p þmax , if h2 rmin g 3 ðt 1 ,n1 ,w,h1 Þ,b, q þp p2 1 1 2 p1 q þðh2 1Þp2 ,0 deðt1 þ h1 p1 ,h2 Þ ¼ , > > : þ 1, otherwise and 8 þ 1, if deðt1 þ h1 p1 ,h2 Þ ¼ h1 p1 > < if t 1 þdeðt1 þ h1 p1 ,h2 Þ Z r nðt1 þ h1 p1 Þ teðt1 þ h1 p1 ,h2 Þ ¼ þ 1, > :d otherwise eðt1 þ h1 p1 ,h2 Þ , m time of the first batch belongs to T m 2 qp1 . Note that T 2 q p1 DT 1 . Then we complete the proof. &

Next, given a scheduling instant, we have the optimal batch size for each job family according to the following theorem: Theorem 12. There exists an optimal schedule such that at each scheduling instant, jobs are batched as fully as possible subject to no violation of limited waiting time constraints. Proof. Given a schedule, suppose that there exists a batch which is not fully batched. No violation of limited waiting time constraints means that adding a job to this batch will not delay the starting time of this batch. Then we can modify the original schedule by moving a job from the next batch to this batch. It can be easily proved that without delaying the starting times of the remaining batches, the limited waiting time constraints for the modified schedule are still satisfied. Hence the makespan will never increase. & Then the state variables of the DP algorithm are constructed as (t1,n1,w), where t1 is the starting time of a group of consecutive batches. n1 is the number of jobs in front of the batching machine at time t1, and w is the direct workload of the discrete machine at time t1. We denote by f(t1,n1,w) the minimum makespan of the unscheduled jobs at the state (t1,n1,w). Then the DP recursion is as follows: (

(

f ðt 1 ,n1 ,wÞ ¼ minh1 min tnðt1 þ h1 p1 Þ t 1 þ f

The boundary condition for the DP recursion (2) is ( w, if r n o t 1 o þ 1 and n1 ¼ 0 : f ðt 1 ,n1 ,wÞ :¼ þ 1, if t 1 ¼ þ1 Then the optimal solution can be found by calculating f ðr 1 ,1,0Þ. Based on the DP recursion, we can easily have the following property: Property 4. The time complexity of the DP algorithm is O(n7). Proof. According to Theorems 10 and 11, the space needed for ! r nðt1 þ h1 p1 Þ ,g 3 ðt 1 ,n1 ,w,h1 Þ þ Uðr j þ hp1 ,r nðrj þ hp1 Þ Þ, maxðg 4 ðt 1 ,n1 ,w,h1 Þtnðt1 þ h1 p1 Þ þ t 1 þ h1 p1 ,0Þ is O(n6), while the space needed for ðt 1 þ deðt1 þ h1 p1 ,h2 Þ ,g 3 ðt 1 ,n1 ,w,h2 Þ þ Uðt 1 þ h2 p1 ,t 1 þ deðt1 þ h1 p1 ,h2 Þ Þ,q þ p2 Þ

is O(n5). Hence, the total number of states cannot exceed O(n6). So the DP algorithm can be implemented to run in O(n7 þbn6) time. Recall that we assume that bon. Thus we have the time complexity of the DP algorithm is O(n7). & Next, we give an efficient optimal procedure for a special case, i.e., p1 op2.

r nðt1 þ h1 p1 Þ ,g 3 ðt 1 ,n1 ,w,h1 Þ þ Uðr j þhp1 ,r nðrj þ hp1 Þ Þ, maxðg 4 ðt 1 ,n1 ,w,h1 Þtnðt1 þ h1 p1 Þ þt 1 þh1 p1 ,0Þ

! , ))

minh2 fteðt1 þ h1 p1 ,h2 Þ þ f ðt 1 þ deðt1 þ h1 p1 ,h2 Þ ,g 3 ðt 1 ,n1 ,w,h2 Þ þ Uðt 1 þ h2 p1 ,t 1 þ deðt1 þ h1 p1 ,h2 Þ Þ,q þ p2 Þg

where g 3 ðt 1 ,n1 ,w,h1 Þ is the number of jobs in front of the batching machine after a group of h1 consecutive batches that start at time t 1 complete. g 4 ðt 1 ,n1 ,w,h1 Þ is the direct workload of the discrete machine after a group of h 1 consecutive batches that start at time t 1 complete. They can be

ð2Þ

It can be easily proved that Theorem 4 is also hold in this case. Hence the optimal algorithm for this problem can be easily implemented as follows: Step 1. Sequence jobs in increasing order of the ready time rj.

1708

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Step 2. Schedule each job according to the sequence. The starting time of the jth job is given by

Property 6. The worst-case performance ratio of the MTSEDD-FIFO heuristic is less than or equal to 2.

maxfr j ,C j1 þ maxfwj1 qp1 ,0gg,

Proof. Let C nmax be the minimum makespan of the problem. C H max is

where Cj  1 is the completion time of the ðj1Þth job on the batching machine. wj  1 is the direct workload of the discrete machine at time Cj  1.

the makespan obtained by the MTSEDD-FIFO heuristic. C H,1 max is the completion time of the last batch obtained by the MTSEDD-FIFO

Property 5. The time complexity of the above procedures is O(n log n). & 5.2. F2/b-d,rj, bon,qk, incompat/Cmax Multiple job families with incompatibility on the batching machine are considered in Section 5.2. Obviously, this problem belongs to NP-complete in strong sense. According to Theorem 9, we can construct the modified TSEDD procedures as follows: MTSEDD procedures

01 01 heuristic. Let C 01 ½p ¼ maxfr ½p ,C ½p1 g þ pk½p , with C ½0 :¼ 0, p¼1,y,9B9.

According to the MTSEDD-FIFO heuristic, we can easily prove P q q p t ½p . (Recall that t ½p is the delay time bet-

01 that C H,1 max rC ½9B9 þ

n ween B[p] and B[p þ 1].) Moreover, we have that C 01 ½9B9 rC max . and P n k nk pk2 rC max . Besides, the procedures of MTSEDD-FIFO heuristic follow that the total processing time that the discrete machine has processed P q before time C H,1 max must be larger than or equal to p t ½p . Therefore the remaining processing time on the discrete machine should be P P less than or equal to k nk pk2  p t q½p . Hence X X X H,1 CH nk pk2  t q½p r C 01 nk pk2 r 2C nmax : max rC max þ ½9B9 þ

p

k

Step 1.

Step 2.

For each family k, starting from the last job, form full bathes greedily such that the first batch contains min(b(qk þpk2/pk2)c,b) jobs, the second batch min(bqk þ pk2/pk2c),b) jobs and so on. Sequence the batches in non-decreasing order of the ready time of the last job in each batch.

Note that we need to determine the starting times on the both machines without violating limited waiting time constraints. Given a sequence of batches and the FIFO rule on the discrete machine, the optimal procedures to determine the starting times of batches on the two machines are as follows: Procedures of the determination of starting times Set p ¼0 and w½0 ¼0. While (p o9B9) { t q½p þ 1 ¼ maxfmaxðw½p pk½p þ 1 1 ,0Þ þ ðn½p þ 1 1Þpk½p þ 1 2 qk½p þ 1 ,0g t 1½p þ 1 ¼ maxðr ½p þ 1 ,C 1½p þ t q½p þ 1 Þ C 1½p þ 1 ¼ t 1½p þ 1 þ pk½p þ 1 1 w½p þ 1 ¼ maxðw½p C 1½p þ 1 þ C 1½p ,0Þ þ n½p þ 1 pk½p þ 1 2 t 2½p þ 1 ¼ C 1½p þ 1 þ w½p þ 1 n½p þ 1 pk½p þ 1 2 p ¼p þ1 } Note that t q½p þ 1 ,p ¼ 0,. . .,9B91, is the delay time caused by the limited waiting time constraint between B[p] and B[p þ 1]. Based on the above optimal procedures, the MTSEDD-FIFO heuristic similar to the TSEDD-FIFO heuristic is constructed as follows: MTSEDD-FIFO heuristic Step 1. Step 2.

Jobs are batched and sequenced according to the MTSEDD procedures. According to the procedures of the determination of starting times, determine t 1½p and t 2½p , p¼1,y,9B9. Jobs in the same batch are sequenced arbitrarily on the discrete machine.

The following property shows the worst-case performance ratio of the MTSEDD-FIFO heuristic.

So we have

n ðC H max =C max Þ r 2.

k

&

If qk ¼ þ N, k ¼1,2y,K, we can easily verify that the performance ratios of three examples obtained by the MTSEDD-FIFO heuristic in Section 4.2 are near 2. Next we construct an example achieving the worst-case performance ratio 2 due to limited waiting time constraints. Example 4. Let K ¼3, b¼T, and the other details are illustrated in Table 4. Applying the MTSEDD-FIFO heuristic, we have C H max ¼ 2T þ2, while the minimum makespan C nmax for this example is Tþ3 (see Fig. 5). Hence CH 2T þ 2 max -2, as T- þ 1: ¼ T þ3 C nmax In what follows we develop Theorems 13–15 to improve the MTSEDD-FIFO heuristic. Theorem 13. For any schedule with the FIFO rule on the discrete machine, consider a job the ready time of which is less than or equal to t 1½j , while its starting time on the batching machine is larger than t 1½j . In addition, this job belongs to family k[j]. If n[j] is less than ($ %$ 2 % ) pk½j 2 þqk½j maxfw½j1 C 1½j þ C 1½j1 ,0g t ½j þ 1 t 2½j , ,b , min pk½j 2 pk½j 2 the makespan will never increase as a result of moving this job to B[j]. Proof. It can be proved that t 1½j þ 1 and t 2½j þ 1 will not increase as a result of moving this job to B[j] if the conditions are satisfied. Besides, the limited waiting time constraints will not be violated. Hence the makespan will never increase. & Theorem 14. For any schedule with the FIFO rule on the discrete machine, if the two adjacent batches B[j] and B[j þ 1] satisfy the

Table 4 Data of Example 4. k 1 2 3

T 1 1

r ik

pk1

pk2

qk

0 1 2

1 1 T

1 1 1

þN 0 þN

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

β

δ

β

δ

Fig. 5. Two schedules of Example 4: (a) the schedule given by the MTSEDD-FIFO heuristic and (b) the optimal schedule.

1709

Step 2. Check each batch in the schedule from B[1] to B[9B9] to find out whether there exists a job satisfying the conditions in Theorem 13, and move this job to the batch if the conditions are satisfied. Step 3. Interchange the adjacent batches as follows: Set i¼0 and j¼ 0. For i¼ 1 to 9B9 For j¼1 to 9B9 i  1 If B[j] and B[j þ 1] satisfy the conditions in Theorem 14 B[j]2B[j þ 1] 0 Update t 1 and t 2 for j ¼j,y,9B9 in the ½j’ ½j’ sequence of batches. End for End for Step 4. Check each batch in the schedule from B[1] to B[9B9] to find out whether there exists a job satisfying the conditions in Theorem 13, and move this job to the batch if the conditions are satisfied. Step 5. Modify the starting time of each batch from front to back as follows: For j ¼2 to 9B9 Set count ¼0, j00 ¼0 If t 1½j 4 C 1½j1 and r ½j o t 1½j (condition 1 in Theorem 15) count ¼ maxfi9qj1 wt½ij1 Zn½j pk½j 2 , f or 0  ½i0 

following conditions:

all 0 r i0 r ig If count40 (condition 2 in Theorem 15)

C1: k[j] ak[j þ 1], 1

C2: t ½j þ 1 þpk½j r t 1½j þ 2 , and

2 C3:t 2½j þ 1 þ n½j þ 1 pk½j þ 1 2 Zt ½j þ 1 þn½j pk½j 2

j00 ¼ maxfj0 9sj1 pk½j 1 Z C 1½j1 ,j0 A f1,2. . ., ½j0 

,

countgg (condition 3 in Theorem 15) If??j00 40

then it is sufficient for the schedule to interchange B[j] and B[j þ 1]. Proof. It can be proved by a pair-wise batch interchange argument. & Before giving another dominance property, we give some further notations: sj is the sequence of jobs on the discrete machine which has been generated from B½1 ,. . .,B½j . sj½i is the starting time of the last ith job in sequence sj and cj½i is the completion time of the last ith job in sequence sj. wt t½i is the waiting time of the last ith job in sequence sj, and qj½i is the limited waiting time of the last ith job in sequence sj.

t 1½j ¼ maxfr ½j ,C 1½j1 ,sj1 pk½j 1 qk½j þðn½j 1Þpk½j 2 g ½j00  . Insert the jobs in B[j] into sequence sj at time sj1 ½j00  Else j1 t 1½j ¼ maxfr ½j ,C 1½j1 ,c½1 pk½j 1 qk½j þðn½j 1Þpk½j 2 g

Append the jobs in B[j] into sequence sj  1 Update wtj½i and sj½i for each job in sequence sj. End for Based on Theorems 13–15, we have the following property.

Theorem 15. For any schedule, if i and B[j] satisfy: C1: t 1½j 4C 1½j1 and r ½j o t 1½j , C2: qj1 wt j1 Z n½j pk½j 2 , for all i0 r i, and ½i0  ½i0 

Property 6. The worst-case performance ratio of Heuristic 2 is less than or equal to 2. For any instance, the makespan obtained by Heuristic 2 is less than or equal to that obtained by the MTSEDD-FIFO heuristic.

C3: sj1 pk½j 1 Z C 1½j1 , ½i

1.08 MTSEDD-FIFO/LB

Proof. Observe that limited waiting time constraints are not violated. It can be proved in comparison with the original schedule. & Remark 2. We can verify that the optimal schedule in Example 4 can be achieved by the resetting procedures according to Theorem 15. Then the improved heuristic is given as follows: Heuristic 2 Step 1. Create a schedule by the MTSEDD-FIFO heuristic.

Heursitic 2/LB

performance ratio

then it is sufficient that the starting time of B[j] on the batching machine is t 1½j ¼ maxfr ½j ,C 1½j1 ,sj1 ½i pk½j 1 qk½j þðn½j 1Þpk½j 2 g and jobs in B[j] is inserted into the sequence of jobs on the discrete machine at time t 2½j ¼ sj1 ½i .

1.06

1.04

1.02

1

0.25

0.5

1 range

1.5

2

Fig. 6. Performance ratios of MTSEDD-FIFO and Heuristic 2 with different range values.

1710

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Proof. Observe that the makespan will never increase by steps 2–5. &

Appendix A Numerical experimental results for Section 4.3. Tables A1–A5.

5.3. Computational results In this subsection computational experiments are conducted to evaluate the performances of the MTSEDD-FIFO heuristic and Heuristic 2. There are no difference between the lower bound in this problem and the lower bound developed in Section 4.3 except that the maximum batch size for each family k modified as min(b(qk þpk2/pk2)c,b) (see Theorem 10). The settings of the experimental parameters, i.e., K, Nk, b, y, pk1, and pk2, can be found in Section 4.3. The limited waiting time qk is generated from 20, 40, 60, 80, and 100 with equal probability. For each combination of the parameters, 100 problem instances are generated and solved, and their computational results are reported in average value (see Appendix B). From Tables B1–B5, we can see that Heuristic 2 performs reasonably well. The average value of Heuristic 2/LB is 1.026, while the average value of MTSEDD-FIFO/LB is 1.054. Moreover, limited waiting time constraints make the problem complicated. Note that in comparison with the TSEDD-FIFO heuristic, the average performance ratios obtained by the MTSEDD-FIFO heuristic is much worse (see the italicized data in Tables B1–B5). Fortunately, Heuristic 2 can improve the solution quality in these instances by 5.27% in comparison with the MTSEDD-FIFO heuristic. Fig. 6 shows the average performance ratio achieved by the MTSEDD-FIFO heuristic and Heuristic 2 with different y. As we can see, the performance trend is quite similar to that in Fig. 4.

6. Conclusion In this paper we discuss a class of two-stage hybrid flow shop problems. When solving the problems with one job family, we found that these problems can be solved optimally within polynomial time. The problems with multiple job families belong to strongly NP-complete. Hence, we give several heuristics for solving them. Numerical experiments are conducted to analyze the effectiveness of these heuristics. Our ongoing work is to generalize the problem where the processing times in the same job family on the discrete machine are unequal, since nonidentical job sizes in the same job family might result in different process times on the discrete machine.

Table A1 Summary of computational results with y ¼ 0.25.

Table A2 Summary of computational results with y ¼0.5. No.

9K9

nk

b

TSEDD-FIFO/LB

Heuristic 1/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0429 1.1091 1.0217 1.0438 1.0146 1.0296 1.0150 1.0342 1.0231 1.1022 1.0127 1.0415 1.0081 1.0274 1.0069 1.0361

1.0333 1.0485 1.0189 1.03 1.0128 1.026 1.0094 1.0153 1.0213 1.035 1.0108 1.0238 1.0062 1.0251 1.0052 1.0131

Table A3 Summary of computational results with y ¼1. No.

9K9

nk

b

TSEDD-FIFO/LB

Heuristic 1/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0370 1.1062 1.0190 1.0566 1.0152 1.0398 1.0107 1.0308 1.0219 1.0990 1.0118 1.0542 1.0101 1.0385 1.0063 1.0346

1.0360 1.0754 1.0179 1.0493 1.0142 1.0388 1.0097 1.0245 1.0209 1.0646 1.0107 1.0470 1.0091 1.0374 1.0053 1.0252

Table A4 Summary of computational results with y ¼1.5.

No.

9K9

nk

b

TSEDD-FIFO/LB

Heuristic 1/LB

No.

9K9

nk

b

TSEDD-FIFO/LB

Heuristic 1/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0406 1.1086 1.0203 1.0392 1.0137 1.0209 1.0168 1.0332 1.0227 1.1117 1.0175 1.0331 1.0065 1.0174 1.0056 1.0345

1.0326 1.0348 1.0152 1.0237 1.0135 1.0205 1.0087 1.0129 1.0225 1.0222 1.0105 1.0170 1.0062 1.0172 1.0045 1.0091

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0241 1.0819 1.0130 1.0406 1.0080 1.0277 1.0066 1.0222 1.0120 1.0563 1.0066 1.0299 1.0044 1.0198 1.0029 1.0153

1.0238 1.0789 1.0128 1.0402 1.0079 1.0276 1.0066 1.0217 1.0120 1.0554 1.0065 1.0296 1.0044 1.0198 1.0029 1.0151

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

Table A5 Summary of computational results with y ¼ 2.

1711

Table B3 Summary of computational results with y ¼ 1.

No.

9K9

nk

b

TSEDD-FIFO/LB

Heuristic 1/LB

No.

9K9

nk

b

MTSEDD-FIFO/LB

Heuristic 2/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0179 1.0600 1.0094 1.0288 1.0060 1.0208 1.0040 1.0154 1.0097 1.0419 1.0051 1.0198 1.0033 1.0164 1.0023 1.0103

1.0176 1.0595 1.0090 1.0287 1.0059 1.0208 1.0039 1.0153 1.0097 1.0409 1.0050 1.0198 1.0032 1.0164 1.0023 1.0103

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0533 1.1167 1.0429 1.0890 1.0474 1.0900 1.0332 1.0754 1.0480 1.1068 1.0430 1.0969 1.0429 1.1037 1.0485 1.1042

1.0298 1.0649 1.0211 1.0466 1.0223 1.0454 1.0131 1.0357 1.0201 1.0502 1.0160 1.0441 1.0161 1.0512 1.0170 1.0462

Table B1 Summary of computational results with y ¼ 0.25.

Table B4 Summary of computational results with y ¼ 1.5.

No.

9K9

nk

b

MTSEDD-FIFO/LB

Heuristic 2/LB

No.

9K9

nk

b

MTSEDD-FIFO/LB

Heuristic 2/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0600 1.1154 1.0385 1.0884 1.0360 1.0869 1.0415 1.0912 1.0544 1.1086 1.0534 1.1074 1.0419 1.1095 1.0456 1.1102

1.0282 1.0562 1.0165 1.0435 1.0153 1.0422 1.0162 1.0400 1.0219 1.0421 1.0186 1.0455 1.0129 1.0512 1.0141 1.0502

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0231 1.0710 1.0138 1.0652 1.0101 1.0460 1.0064 1.0463 1.0138 1.0685 1.0096 1.0640 1.0042 1.0529 1.0029 1.0544

1.0161 1.0459 1.0100 1.0394 1.0060 1.0252 1.0044 1.0223 1.0089 1.0403 1.0051 1.0314 1.0026 1.0246 1.0019 1.0243

Table B2 Summary of computational results with y ¼ 0.5.

Table B5 Summary of computational results with y ¼ 2.

No.

9K9

nk

b

MTSEDD-FIFO/LB

Heuristic 2/LB

No.

9K9

nk

b

MTSEDD-FIFO/LB

Heuristic 2/LB

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0586 1.0995 1.0512 1.1037 1.0412 1.0955 1.0340 1.0821 1.0474 1.1128 1.0481 1.1008 1.0363 1.1113 1.0427 1.1076

1.0303 1.0490 1.0209 1.0478 1.0183 1.0478 1.0136 1.0374 1.0192 1.0456 1.0190 1.0448 1.0122 1.0513 1.0140 1.0480

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

5 5 5 5 5 5 5 5 10 10 10 10 10 10 10 10

20 20 40 40 60 60 80 80 20 20 40 40 60 60 80 80

4 6 4 6 4 6 4 6 4 6 4 6 4 6 4 6

1.0204 1.0480 1.0120 1.0300 1.0100 1.0256 1.0089 1.0258 1.0141 1.0359 1.0094 1.0224 1.0082 1.0178 1.0073 1.0145

1.0175 1.0393 1.0106 1.0233 1.0088 1.0177 1.0082 1.0181 1.0116 1.0264 1.0082 1.0166 1.0073 1.0134 1.0066 1.0107

References

Appendix B Numerical Tables B1–B5.

experimental

results

for

Section

5.3.

[1] Su L-H. A hybrid two-stage flowshop with limited waiting time constraints. Computers & Industrial Engineering 2003;44(3):409–24.

1712

F.S. Yao et al. / Computers & Operations Research 39 (2012) 1701–1712

[2] Ahmadi JH, Ahmadi RH, Dasu S, Tang CS. Batching and scheduling jobs on batch and discrete processors. Operations Research 1992;40(4):750–63. [3] Sung CS, Kim YH. Minimizing makespan in a two-machine flowshop with dynamic arrivals allowed. Computers & Operations Research 2002;29(3): 275–94. [4] Kis T, Pesch E. A review of exact solution methods for the non-preemptive multiprocessor flowshop problem. European Journal of Operational Research 2005;164(3):592–608. [5] Ruiz R, Vazquez-Rodriguez JA. The hybrid flow shop scheduling problem. European Journal of Operational Research 2010;205(1):1–18. [6] Lee CY, Uzsoy R. Minimizing makespan on a single batch processing machine with dynamic job arrivals. International Journal of Production Research 1999;37(1):219–36. [7] Fowler J, Phillips DT, Hogg GL. Real-time control of multiproduct bulk-service semiconductor manufacturing processes. IEEE Transaction on Semiconductor Manufacturing 1992;5(2):158–63. [8] Fowler JW, Hogg GL, Phillips DT. Control of multiproduct bulk server diffusion/oxidation processes. Part 2: multiple servers. IIE Transaction 2000; 32(2):167–76. [9] Weng WW, Leachman RC. An improved methodology for real-time production decisions at batch-process work stations. IEEE Transaction on Semiconductor Manufacturing 1993;6(3):219–25. [10] Robinson J, Fowler J, Bard J. The use of upstream and downstream information in scheduling semiconductor batch operations. International Journal of Production Research 1995;33(7):1849–69. [11] Uzsoy R. Scheduling batch processing machines with incompatible job families. International Journal of Production Research 1995;33(10): 2685–708. [12] Ahmadi JH, Ahmadi RH, Dasu S, Tang CS. Batching and scheduling jobs on batch and discrete processors. Operations Research 1992;40(4):750–63. [13] Sung CS, Kim YH, Yoon SH. A problem reduction and decomposition approach for scheduling for a flowshop of batch processing machines. European Journal of Operational Research 2000;121(1):179–92.

[14] Cheng TCE, Lin BMT, Toker A. Makespan minimization in the two-machine flowshop batch scheduling problem. Naval Research Logistics 2000;47: 128–44. [15] Wang J-T, Chern M-S, Yang D-LA. Two-machine multi-family flowshop scheduling problem with two batch processors. Journal of the Chinese Institute of Industrial Engineers 2001;18(3):77–85. [16] Yang D-L, Chern M-S. A two-machine flowshop sequencing problem with limited waiting time constraints. Computers & Industrial Engineering 1995; 28(1):63–70. [17] Joo B-J, Kim Y-D. A branch-and-bound algorithm for a two-machine flowshop scheduling problem with limited waiting time constraints. Journal of Operational Research Society 2009;60(4):572–82. [18] Damodaran P, Srihari K. Mixed integer formulation to minimize makespan in a flow shop with batch processing machines. Mathematical and Computer Modeling 2004;40(13):1465–72. [19] Su L-H, Chen JC. Sequencing two-stage flowshop with nonidentical job sizes. The International Journal of Advanced Manufacturing Technology 2010; 47(1):259–68. [20] Gong H, Tang L, Duin CW. A two-stage flow shop scheduling problem on a batching machine and a discrete machine with blocking and shared setup times. Computers & Operations Research 2010;37(5):960–9. [21] Oulamara A. Makespan minimization in a no-wait flow shop problem with two batching machines. Computers & Operations Research 2007;34(4):1033–50. [22] Lin BMT, Cheng TCE. Batch scheduling in the no-wait two-machine flowshop to minimize the makespan. Computers & Operations Research 2001;28(7):613–24. [23] Tang L, Liu P. Flowshop scheduling problems with transportation or deterioration between the batching and single machines. Computers & Industrial Engineering 2009;56(4):1289–95. [24] Allaoui H, Artiba A. Integrating simulation and optimization to schedule a hybrid flow shop with maintenance constraints. Computers & Industrial Engineering 2004;47(4):431–50. [25] Webster S, Baker KR. Scheduling groups of jobs on a single machine. Operations Research 1995;43(4):692–703.