Mathematical and Computer Modelling 49 (2009) 1071–1077
Contents lists available at ScienceDirect
Mathematical and Computer Modelling journal homepage: www.elsevier.com/locate/mcm
Minimizing makespan in a two-machine flowshop scheduling with batching and release time Lixin Tang ∗ , Peng Liu The Logistics Institute, Northeastern University, Shenyang, 110004, China
article
info
Article history: Received 15 February 2008 Received in revised form 29 August 2008 Accepted 16 September 2008
Keywords: Flowshop scheduling Batching Release time Lower bound Heuristic
a b s t r a c t This paper studies two-machine flowshop scheduling with batching and release time, whose objective is to minimize the makespan. We formulate the scheduling problem as a mixed integer programming model and show that it is a strongly NP-hard problem. We derive a lower bound and develop dynamic programming-based heuristic algorithms to solve the scheduling problem. Computational experiments are carried out to evaluate the performance of the heuristic algorithms. The numerical results show that some of the heuristic algorithms can indeed find effective solutions for the scheduling problem. © 2008 Elsevier Ltd. All rights reserved.
1. Introduction We consider the following two-machine flowshop scheduling problem with batching and release time, whose objective is to minimize the makespan. A set of n independent and non-preemptive jobs N = {1, 2, . . . , n} are to be processed at a two-machine flowshop, where the first machine processes one job at a time and the second machine processes jobs in batches. The processing times of job j on the first machine and the second machine are denoted by p1j and p2j , respectively. Jobs arrive dynamically at the first machine and the release time of job j at the first machine is denoted by rj . A constant setup time s is incurred whenever a batch is formed on the second machine. The setup for the second machine can be performed prior to arrivals of jobs which form a batch from the first machine. Jobs are processed in batches on the second machine and the number of jobs in a batch is called the batch size. Batch sizes are numbers between 1 and n. The processing time of a batch on the second machine is defined as the sum of the processing times of all jobs belonging to it plus the setup time, and thus the batch on the second machine is a serial batch. The objective is to find the optimal schedule which minimizes the makespan, i.e., the maximum completion time of all jobs. By using the three-field notation ψ1 |ψ2 | ψ3 of Graham et al. [1], we denote the scheduling problem by F 2 1 → b, rj , s Cmax . In the ψ2 field, ‘‘1 → b’’ denotes the first machine processes jobs individually and the second machine processes jobs in batches, ‘‘rj ’’ denotes the release time of job j and ‘‘s’’ denotes the setup time. As a practical example of the proposed problem, we may consider the steel-making process in the steel plant (see Fig. 1, also see Tang et al. [2] and Tang and Wang [3]). The steel-making process includes steel-making, refining and continuouscasting stages, where a charge, a concurrent smelting in the same converter, is regarded as a ‘‘job’’ in steel-making process scheduling. The charges with molten steel coming from the steel-making stage arrive dynamically to the refining stage where some refining furnaces are used to refine the charges. After refining, these charges are processed on continuous casters at the
∗
Corresponding author. Tel.: +86 24 83680169; fax: +86 24 83680169. E-mail addresses:
[email protected] (L. Tang),
[email protected] (P. Liu).
0895-7177/$ – see front matter © 2008 Elsevier Ltd. All rights reserved. doi:10.1016/j.mcm.2008.09.012
1072
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
Fig. 1. The process of steel-making.
continuous-casting stage. A sequence of charges that are consecutively produced via the same tundish is called a cast, which is defined as a ‘‘batch’’ in steel-making process scheduling. A setup time is needed between two casts on the same caster for changing the tundish. There exists often a bottleneck furnace at the refining stage which processes one charge at a time. Since charges within the same cast are processed sequentially on a continuous caster, this batch production is referred to as serial batch. The scheduling for both the refining stage and the continuous-casting stage while jobs dynamically coming from the steel-making stage is a motivation for our considered problem. Next, we briefly review the literature related to this paper. Extensive surveys of different models and problems with batching can be found in Potts and Van Wassenhove [4], Webster and Baker [5], and Potts and Kovalyov [6]. Damodaran and Srihari [7] propose mixed integer formulations for the flowshop problem when the buffer capacity is unlimited or zero. The processing time of a batch is the maximum processing time of all jobs in the batch. Numerical examples are presented to demonstrate the application of the model. Ahmadi et al. [8] consider the problem of scheduling a two-stage flowshop in which one or both the stages may comprise a batch processor. The processing time of a batch is a constant regardless of the number of jobs contained in it. They study the complexity analysis for two problem instances with the objective of the makespan and the total completion time. Tang and Liu [9] consider the two-machine flowshop scheduling problems involving a batching machine with transportation or deterioration consideration. The processing time of a batch is also a constant. Our work differs from the models of Damodaran and Srihari [7], Ahmadi et al. [8] and Tang and Liu [9] in that we consider the processing time of a batch is not a constant or the maximum processing time of all jobs in the batch but the sum of the processing times of its jobs in the batch plus the setup time. Lee and Uzsoy [10] consider the problem of minimizing makespan on a single batch processing machine in the presence of dynamic job arrivals. The processing time of a batch is also given by the maximum processing time of all jobs in the batch. Sung and Kim [11] further study one of the models of Ahmadi et al. [8]. They investigate a scheduling problem for a two-machine flowshop with a discrete processing machine followed by a batch processing machine to minimize makespan where dynamic job arrivals are allowed. Although Lee and Uzsoy [10] and Sung and Kim [11] pay attention to the release time of jobs, the difference between our model and these works is that we consider a serial batch instead of parallel one on the second machine. Cheng and Wang [12] consider the two-machine flowshop where one of the machines is a discrete processor and the other one is a batch processor. The processing time of a batch is the total processing time of the jobs contained in it. They show that the problem is NP-hard in the ordinary sense and propose efficient algorithms for some polynomial solvable cases. Cheng et al. [13] consider the same configuration except that both machines process the jobs in batches. They develop strong NP-hardness proofs, present properties and polynomial algorithms for some special cases, and propose heuristic algorithms to deal with the general problem. Another paper by Lin and Cheng [14] studies a two-machine flowshop scheduling problem where a discrete processor is followed by a batch processor. They show that the problem is strongly NP-hard and design some heuristic algorithms for deriving approximate solutions. The literature mentioned above cover the scheduling with batching, however, the above three papers do not consider the scheduling with the situation where different release times are allowed at the first machine. There are reviews of models which combine scheduling involving setup times by Allahverdi et al. [15] and Cheng et al. [16]. Eren and Guner [17] consider a bicriteria scheduling problem with sequence-dependent setup times on a single machine. They develop an integer programming model for the problem. Mosheiov and Oron [18] consider a single machine scheduling problem with identical jobs and batch-dependent setup times. They formulate the problem as a mathematical model and introduce an efficient solution procedure. Although our problem also considers setup time which is different from the above ones, we are in addition to taking the release time of jobs and the serial batch on the second machine into consideration. The remainder of the paper is organized as follows. In Section 2, the proposed mixed integer programming model is given. In Section 3, we derive a lower bound for the scheduling problem. In Section 4, heuristic algorithms and its computational experiments are proposed. Finally, some concluding remarks are made in Section 5.
2. Mathematical model In this section, the scheduling problem F 2 1 → b, rj , s Cmax is formulated as a mixed integer programming model. The parameters and variables in the model are described below and then the proposed model is given.
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
1073
Parameters: N rj p1j p2j s M
The set of all jobs, N = {1, 2, . . . , n}, where n is the total number of jobs. The release time of job j. The processing time of job j on the first machine. The processing time of job j on the second machine. The setup time. A sufficiently large positive constant.
Decision variables: xij yjk zj,j+1 B C1j C2j
1, if job i is processed before job j; 0, otherwise. 1, if job j belongs to the kth batch; 0, otherwise. 1, if yjk and yj+1,k are equal to 1; 0, otherwise. The number of batches. The completion time of job j on the first machine. The completion time of job j on the second machine.
Mixed integer programming model: Objective function: Minimize
(1)
Cmax
Subject to:
C1j ≥ rj + p1j ,
j = 1, 2, . . . , n,
(2)
C1j − C1i ≥ p1j − 1 − xij M ,
i, j = 1, 2, . . . , n, and i 6= j,
(3)
C1i − C1j ≥ p1i − 1 − xji M ,
i, j = 1, 2, . . . , n, and i 6= j,
(4)
xij + xji = 1, Cmax ≥ C2j , B X
i, j = 1, 2, . . . , n, and i 6= j,
(5)
j = 1 , 2 , . . . , n,
(6)
yjk = 1,
j = 1, 2, . . . , n, 1 ≤ B ≤ n,
(7)
yjk ≤ n,
k = 1, 2, . . . , B, 1 ≤ B ≤ n,
(8)
k=1 n X j=1
zj,j+1 =
yjk + yj+1,k /2 ,
j = 1, 2, . . . , n − 1; k = 1, 2, . . . , B,
C2,j+1 ≥ C2j + p2,j+1 + s 1 − zj,j+1 ,
xij , yjk , zj,j+1 ∈ {0, 1} , C1j , C2j ≥ 0,
(9)
j = 1, 2, . . . , n − 1,
(10)
k = 1, 2, . . . , B; i, j = 1, 2, . . . , n, and i 6= j,
(11)
j = 1, 2, . . . , n.
(12)
The objective function (1) minimizes the makespan, i.e., the maximum completion time of all jobs. Constraint (2) gives the relationship between a job’s completion time, release time and processing time on the first machine. Constraints (3)–(5) make sure that there is no overlapping between any two jobs on the first machine. Constraint (6) defines the properties of decision variables Cmax and C2j . Constraint (7) guarantees that each job must be belonged to one batch exactly once. Constraint (8) ensures that the number of jobs scheduled in one batch cannot exceed the total number of jobs. Constraint (9) defines the decision variable zj,j+1 . Constraint (10) gives that the relationship between two jobs’ completion time and setup time on the second machine. Finally, constraints (11) and (12) define the range of the variables. 3. Lower bound In this section, we develop a lower bound of the makespan for the problem F 2 1 → b, rj , s Cmax . Before proposing the lower bound, we first state the computational complexity of the scheduling problem. Lin and Cheng [14] show that the two-machine flowshop problem where a discrete processor is followed by a batch processor for minimizing the makespan is strongly NP-hard, which can be viewed as a special case of our problem with no release time. Therefore, our general problem F 2 1 → b, rj , s Cmax is also strongly NP-hard. Consequently, we have the following theorem.
Theorem 1. The problem F 2 1 → b, rj , s Cmax is NP-hard in the strong sense.
1074
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
Now we develop the lower bound. We will call the release times and the processing times of jobs are agreeable if, for any two jobs i and j, if ri ≤ rj , then p1i ≤ p1j and p2i ≥ p2j . For example, the agreeable relation is satisfied in the case where all the processing times of jobs on the first machine and the second machine are the same constant. We denote the problem with the agreeable relation as F 2 |1 → b, agr , s| Cmax . Next, we propose the following lemma that is described in Gupta [19]. Consider two schedules S = P π and S 0 = P 0 π where the partial schedules P and P 0 are different permutations of the same subset of jobs. Let T (P , m) denote the completion time of partial schedule P at machine m in the flowshop. Lemma 1 (Gupta [19]). P and P 0 that are different permutations of the same subsets of jobs. If Consider two partial 0schedules 0 T (P , m) ≤ T P , m , then T (P π , m) ≤ T P π , m . For the problem F 2 |1 → b, agr , s| Cmax , we have the following result. Lemma 2. Consider the problem F 2 |1 → b, agr , s| Cmax with the job set N = {1, 2, . . . , n}, and let Si∗ be optimal among all schedules for the job subset {1, 2, . . . , i}. Then, schedule Si∗ BL for the job set N = {1, 2, . . . , n}, where BL is the batch formed by jobs i + 1, . . . , n, is optimal among all schedules with BL as the last batch. Proof. The proof is straightforward from the result of Lemma 1.
Lemma 2 gives a useful insight for constructing a dynamic programming algorithm for dealing with the problem F 2 |1 → b, agr , s| Cmax . Let C1i and C2i denote the completion time on the first machine and the second machine, respectively, of an optimal solution for scheduling jobs in {1, 2, . . . , i}. Then, we have an optimal schedule for the problem F 2 |1 → b, agr , s| Cmax by the following dynamic programming algorithm. Algorithm DP The boundary condition: C10 = C20 = 0. The recurrence relation: C1i = max ri , C1,i−1 + p1i ,
( C2i =
min
l=1,2,...,i
max C1i , C2,i−l + s +
i X
) p2j
,
j=i−l+1
where l indicates the number of jobs to be included in the last batch. The optimal solution: C2n . The time complexity of the Algorithm DP is O n3 . Therefore, the problem F 2 |1 → b, agr , s| Cmax is solvable in O n3 time. Algorithm DP mentioned above not only provides an approach to solve F 2 |1 → b, agr , s| Cmax , but also is the problem extended to find an effective lower bound for the general problem F 2 1 → b, rj , s Cmax . The lower bound is the solution obtained from applying Algorithm DP to a transformed job set. The idea follows from Cheng et al. [13]. Let N 0 be a job set transformed from job set N by letting rj0 be the jth smallest value in {r1 , r2 , . . . , rn }, p01j be the jth smallest value in {p11 , p12 , . . . , p1n } and p02j be the jth largest value in {p21 , p22 , . . . , p2n }. It is apparent that job set N 0 satisfies the condition specified in the problem F 2 |1 → b, agr , s| Cmax and can be solved using Algorithm DP. We propose the following theorem that establishes a relationship between the solutions for sets N and N 0 , and we identifies a useful property that an optimal solution for the special case is a lower bound for the general problem for the data transformation. Theorem 2. For any schedule S for the problem F 2 1 → b, rj , s Cmax with the job set N, there exists a schedule S 0 for the
corresponding problem F 2 |1 → b, agr , s| Cmax with the derived job set N 0 such that Cmax S 0 ≤ Cmax (S ).
Proof. Given any schedule S for F 2 1 → b, rj , s Cmax with job set N, we make the following transformation: For any job pair i and j in schedule S, if job i precedes job j and ri > rj , then we swap the release time of job i and j but leave the processing time unchanged. It is clear that the makespan cannot be increased. After performing all necessary swaps, we will have a new schedule in which all jobs are arranged in non-decreasing order of their release times. With the new schedule that ri ≤ rj , if job i precedes job j and p1i > p1j , then we interchange the processing times of jobs i and j on the first machine without altering the processing times on the second machine. It is not hard to see that the makespan cannot be increased. Continuing the interchange process until there are no such jobs as i and j, we will have a new schedule in which all jobs on the first machine are arranged in non-decreasing order of their processing times. With the derived schedule that ri ≤ rj and p1i ≤ p1j , if job i precedes job j and p2i < p2j , then we re-arrange the processing times on the second machine in a 0 non-increasing order. Similarly, the makespan is not increased. After the transformations are finished, we obtain schedule S 0 and the jobs satisfy the definition of job set N . The final derived schedule is a solution for the problem F 2 1 → b, rj , s Cmax
and yields a makespan no less than Cmax S 0 , which is optimal for the problem F 2 |1 → b, agr , s| Cmax . Therefore, the proof is complete.
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
1075
Table 1 Computational results of average error ratio (%). n
s
50
100
200
300
50 150 300 400 50 150 300 400 50 150 300 400 50 150 300 400
a = 0.1
a = 0.5
a=1
H1
H2
H3
H4
H1
H2
H3
H4
H1
H2
H3
H4
11.09 12.06 10.49 11.32 9.38 11.94 12.63 11.17 7.09 10.04 11.38 12.13 6.01 9.20 10.69 11.20
3.16 4.30 4.00 6.26 2.05 3.66 4.62 3.53 1.31 2.60 3.53 4.19 0.96 2.24 2.96 3.31
3.70 5.14 4.34 7.54 2.59 4.52 5.37 4.85 1.73 3.38 4.45 5.30 1.25 2.72 3.68 4.02
3.86 4.72 4.18 6.58 2.37 3.86 4.77 3.69 1.38 2.64 3.56 4.18 0.98 2.24 2.97 3.31
11.20 12.32 10.65 11.50 9.02 11.85 12.47 11.00 7.16 10.21 11.49 12.25 6.20 9.36 10.87 11.36
3.36 4.55 4.07 6.72 2.37 4.01 4.91 3.88 1.82 3.00 3.90 4.55 1.56 2.61 3.35 3.60
4.00 5.37 4.33 7.77 2.88 4.79 5.62 4.98 2.11 3.69 4.66 5.58 1.62 3.04 3.93 4.29
3.51 4.52 4.02 6.59 2.29 3.88 4.78 3.69 1.63 2.85 3.75 4.37 1.31 2.50 3.23 3.50
11.10 12.26 10.33 11.43 9.22 12.00 12.51 11.12 7.18 10.22 11.58 12.33 6.06 9.27 10.80 11.27
3.82 5.04 4.29 6.94 3.07 4.47 5.35 4.38 2.62 3.63 4.40 5.07 2.35 3.40 3.87 4.10
4.36 5.69 4.49 7.89 3.42 5.21 6.00 5.31 2.61 4.16 5.09 5.93 2.25 3.68 4.47 4.85
3.72 4.67 3.94 6.58 2.65 4.12 5.02 3.93 2.17 3.41 4.23 4.87 1.91 3.15 3.72 3.96
4. Heuristic algorithms and computational experiments Although the mixed integer programming model provides the optimal solution, variables and constraints increase drastically when the number of jobs increases. Theorem 1 indicates that the existence of a polynomial time algorithm to solve our scheduling problem is unlikely. So developing fast heuristic algorithm for yielding near-optimal solutions is justifiable. In this section, we present heuristic algorithms to find approximate solutions. Computational experiments are carried out to evaluate the effectiveness of these proposed heuristic algorithms. The heuristic algorithms are made up of two phases: job sequencing and job batching. In the second phase, we can find an optimal job batching for a given job sequence using Algorithm DP presented in Section 3. Hence, our heuristic algorithms are to decide on job sequencing. In the first phase, we present four strategies for job sequencing as follows. Heuristic 1: arrange the jobs by non-decreasing order of rj . Heuristic 2: arrange the jobs by non-decreasing order of p1j . Heuristic 3: arrange the jobs by non-increasing order of p2j . Heuristic 4: arrange the jobs by Dynamic Shortest Processing Time p1j rule (DSPT: When a job is finished, start another job which has the shortest processing time p1j among those of the currently available jobs). The heuristic algorithms are coded in Visual C++ language and implemented on the computer with 512 MB RAM and 256 KB L2 cache. For the experiments, the following parameters are considered to generate randomly the test problems: Numbers of jobs (n): 50, 100, 200, 300; Setup time (s): 50, 150, 300, 400; Processing times of jobs (p1j and p2j ): generated from the discrete uniform distribution with range [1, 100]; Release time (rj ): [1, a · n] for a = 0.1, 0.5, 1. In order to evaluate the performance of heuristic algorithms, we use the lower bound Cmax S 0 derived in Section 3. Based on the lower bound Cmax S 0 , the relative error ratio is defined as ER = Cmax (Hi) − Cmax S 0 /Cmax S 0 × 100%, where Cmax (Hi) denotes the makespan of the schedule generated by heuristic algorithm Hi, i = 1, 2, 3, 4. The Average Error Ratio and the Maximum Error Ratio measured over the derived lower bound of the makespan are used for the performance test. For each parameter combination, 100 random problems are generated for the performance test of the heuristic algorithms. We do not report CPU times since even the largest problems are solved in a matter of minutes and there are no significant differences in CPU times between the methods. The results of the evaluation are given in Tables 1 and 2. Results of computational experiments reveal that heuristic algorithm H4 almost totally dominates the other three methods and the performance of heuristic algorithm H4 is effective in obtaining near-optimal solutions. They also reveal that the lower bound is close to the optimal solutions. From the computational results of average error ratio, we observe that the error ratios appear in a decreasing trend as the value of n increases (see Fig. 2). We also observe that the error ratios appear in an increasing trend as the value of a increases, i.e., the heuristic solutions get worse as the variation range of the release times gets wider (see Fig. 3). Furthermore, the heuristic algorithms exhibit minor error ratios when the setup time is relatively small (see Fig. 4).
5. Conclusions In this paper, two-machine flowshop scheduling problem with batching and release time is studied. The objective is to minimize the makespan. We propose a mixed integer programming model to solve the scheduling problem and derive a lower bound for the problem. It is shown that the scheduling problem is a strongly NP-hard problem. Some dynamic
1076
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
Table 2 Computational results of maximum error ratio (%). n
s
50
100
200
300
50 150 300 400 50 150 300 400 50 150 300 400 50 150 300 400
a = 0.1
a = 0.5
a=1
H1
H2
H3
H4
H1
H2
H3
H4
H1
H2
H3
H4
21.07 20.36 17.16 17.72 16.69 21.10 21.31 20.16 11.78 14.42 14.82 16.17 10.10 12.47 14.58 14.57
6.25 9.99 8.35 12.50 3.99 6.61 8.93 9.28 2.34 4.38 5.64 6.68 1.88 3.55 5.05 5.10
6.57 8.78 10.21 12.50 4.33 6.65 8.18 7.68 2.82 5.07 6.14 7.34 2.24 3.91 5.05 5.53
7.63 9.99 8.89 12.50 4.62 6.59 8.93 9.13 2.38 4.38 5.64 6.63 1.79 3.52 5.05 5.16
19.69 20.73 17.10 18.41 17.53 19.56 19.21 19.48 12.78 14.54 16.71 15.65 9.43 12.62 14.53 14.65
6.96 9.51 9.31 12.57 4.62 7.07 9.25 9.80 2.85 4.87 6.85 7.18 2.41 3.76 5.87 6.06
7.83 9.60 10.46 13.46 5.31 6.89 8.77 7.80 3.43 5.47 6.08 7.31 2.86 4.56 5.32 5.65
7.11 10.78 9.21 12.57 4.75 6.65 9.25 9.42 2.54 4.50 6.31 6.72 2.31 3.70 5.87 5.62
20.60 21.07 17.08 18.82 16.65 19.22 19.76 19.26 13.23 15.07 15.15 16.03 9.15 12.15 15.15 15.60
7.66 9.70 9.36 12.50 5.39 7.88 9.81 10.78 3.69 5.39 8.01 7.19 3.58 4.73 6.35 6.70
8.78 10.11 10.46 13.50 6.46 7.46 9.23 8.25 4.49 5.86 6.83 7.90 3.91 5.38 5.83 6.76
7.32 10.73 9.36 12.50 4.78 7.66 9.24 9.50 3.25 5.09 7.35 7.04 3.18 4.63 6.25 6.70
Fig. 2. Average error ratios of the four heuristics with s = 150 and a = 0.5.
Fig. 3. Average error ratios of algorithm H4 with s = 150.
programming-based heuristic algorithms are thus proposed to find effective schedules for the problem. Computational experiments are used to illustrate the heuristic algorithms. The performance of the heuristic algorithms is evaluated by using a set of test problems. The computational results show that some of the heuristic algorithms work well for most of the test problems.
L. Tang, P. Liu / Mathematical and Computer Modelling 49 (2009) 1071–1077
1077
Fig. 4. Average error ratios of algorithm H4 with a = 0.5.
Many interesting topics remain for future exploration. We may assume that the processing time of a batch is the maximum processing time of the jobs grouped together in the batch. In addition, it may be interesting to consider the scheduling problem with other relevant performance measures, such as total completion time, maximum tardiness, and number of tardy jobs. Acknowledgements The authors would like to thank the anonymous referees for their helpful comments and suggestions. This research is partly supported by National Natural Science Foundation for Distinguished Young Scholars of China (Grant No. 70425003), National 863 High-Tech Research and Development Program of China through approved No. 2006AA04Z174 and National Natural Science Foundation of China (Grant No. 60674084). References [1] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic sequencing and scheduling theory: A survey, Annals of Discrete Mathematics 5 (1979) 287–326. [2] L. Tang, P.B. Luh, J.Y. Liu, L. Fang, Steel-making process scheduling by Lagrangian relaxation, International Journal of Production Research 40 (2002) 55–70. [3] L. Tang, G. Wang, Decision support system for the batching problems of steel-making and continuous-casting production, Omega 36 (2008) 976–991. [4] C.N. Potts, L.N. Van Wassenhove, Integrating scheduling with batching and lot-sizing: A review of algorithms and complexity, Journal of the Operational Research Society 43 (1992) 395–406. [5] S. Webster, K.R. Baker, Scheduling groups of jobs on a single machine, Operations Research 43 (1995) 692–703. [6] C.N. Potts, M.Y. Kovalyov, Scheduling with batching: A review, European Journal of Operational Research 120 (2000) 228–249. [7] P. Damodaran, K. Srihari, Mixed integer formulation to minimize makespan in a flowshop with batch processing machines, Mathematical and Computer Modelling 40 (2004) 1465–1472. [8] J.H. Ahmadi, R.H. Ahmadi, S. Dasu, C.S. Tang, Batching and scheduling jobs on batch and discrete processors, Operations Research 39 (1992) 750–763. [9] L. Tang, P. Liu, Two-machine flowshop scheduling problems involving a batching machine with transportation or deterioration consideration, Applied Mathematical Modelling 33 (2009) 1187–1199. [10] 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. [11] C.S. Sung, Y.H. Kim, Minimizing makespan in a two-machine flowshop with dynamic arrivals allowed, Computers and Operations Research 29 (2002) 275–294. [12] T.C.E. Cheng, G. Wang, Batching and scheduling to minimize the makespan in the two-machine flowshop, IIE Transactions 30 (1998) 447–453. [13] T.C.E. Cheng, B.M.T. Lin, A. Toker, Makespan minimization in the two-machine flowshop batch scheduling problem, Naval Research Logistics 47 (2000) 128–144. [14] B.M.T. Lin, T.C.E. Cheng, Two-machine flowshop batching and scheduling, Annals of Operations Research 133 (2005) 149–161. [15] A. Allahverdi, J.N.D. Gupta, T. Aldowaisan, A review of scheduling research involving setup considerations, Omega 27 (1999) 219–239. [16] T.C.E. Cheng, J.N.D. Gupta, G. Wang, A review of flowshop scheduling research with setup times, Production and Operations Management 9 (2000) 262–282. [17] T. Eren, E. Guner, A bicriteria scheduling with sequence-dependent setup times, Applied Mathematics and Computation 179 (2006) 378–385. [18] G. Mosheiov, D. Oron, Single machine scheduling with batch-dependent setup times, Information Processing Letters 98 (2006) 73–78. [19] J.N.D. Gupta, An improved combinatorial algorithm for the flowshop scheduling problem, Operations Research 19 (1971) 1753–1758.
