www.elsevier.com/locate/dsw
A heuristic for scheduling two-machine no-wait ow shops
with anticipatory setups
Jerey B. Sidney
a, Chris N. Potts
b, Chelliah Sriskandarajah
c;∗aUniversity of Ottawa, Canada bUniversity of Southampton, UK
cUniversity of Texas at Dallas, School of Management, Mail Station J04. 7, Box 830688, Richardson, TX 75083-0688, USA
Received 1 October 1998; received in revised form 1 December 1999
Abstract
We consider a problem of scheduling jobs in two-machine no-wait ow shops for which the objective is to minimize the makespan. Each job, upon completion of its processing on the rst machine, must be transferred immediately to the second machine due to a no-wait in process constraint. Every job requires a setup time on each machine before it is processed. The setup on the second machine is anticipatory, since it can be performed in advance of an arriving job, and consists of two parts. During the rst part of the setup, the job should not be present in the machine, while the second part of setup can be done in the presence or absence of the job. A heuristic algorithm is proposed, and its worst-case performance ratio of 4=3 is established. c 2000 Elsevier Science B.V. All rights reserved.
Keywords:No-wait ow shop; Deterministic scheduling; Setup; Heuristic algorithm; Worst-case analysis; Performance bounds
1. Introduction
The following version of the two-machine no-wait ow shop problem is considered. Each job, upon com-pletion of its processing on the rst machine, must be transferred immediately to the second machine due to a no-wait in process constraint. Further, every job requires a setup time on each machine before it is processed. The setup on the second machine is anti-cipatory, since it can be performed in advance of an
∗Corresponding author. Fax: +1-972 883-2089.
E-mail address:[email protected] (C. Sriskandarajah).
arriving job, and consists of two parts. During the rst part of the setup, the job should not be present in the machine, while the second part of setup can be done in the presence or absence of the job. The rst part of the setup is machine specic to the operation, such as calibration and testing of a tool on a specimen, and the presence of job may make it dicult or impossible to perform the setup.
Scheduling no-wait shops has been the focus of considerable attention from both practitioners and the-oreticians for a number of years. In such a shop, suc-cessive operations of a job must be performed with no intervening idle time. In the chemical, petrochem-ical and hot rolling mill industries, such constraints
model physical requirements of the production process (e.g., cooling must not take place between successive operations). In other cases, if a bottleneck machine has no available storage facilities for leaving inventory, no-wait constraints may be imposed to achieve max-imum utilization of the facility. The reader may refer to the survey papers on no-wait scheduling by Goyal and Sriskandarajah [6], and Hall and Sriskandarajah [9]. Useful general references on machine scheduling problems include the books by Baker [1] and Pinedo [12]. Inuential survey articles have been written by Graham et al. [7], Lawler et al. [10], and Chen et al. [2].
The remaining sections of this paper are organized as follows. In Section 2, we provide notations and give a description of the problem. Section 3 provides a transformation that allows us to restrict the range of instances that we consider. In Section 4, we present our heuristic for the problem, and establish an upper bound on its worst-case performance. Some worst-case ex-amples are given in Section 5. Finally, in Section 6, we combine the results of the previous two sections to establish the worst-case performance ratio of our heuristic.
2. Problem description
In this paper, we deal with the two-machine no-wait ow shop scheduling problem of mini-mizing makespan Cmax, where jobs have setups
on the machines. Let M1; M2 denote the two
ma-chines in the ow shop. The problem is denoted by
F2|no-wait; setup{cj; dj} |Cmax. An instance of this
problem is given by:{(aj; bj; cj; dj)|06aj; 06cj6 dj6bj; j∈N}, where ndenotes the number of jobs
to be processed; N the set of jobs {1; : : : ; n} to be processed; aj the processing time (including setup
time) of job j on machine M1; bj the processing
time (including setup time) of job j on machine
M2; dj the total setup time of job j on machine M2; cjthe rst portion of setup time of jobjon
ma-chineM2during which the job should not be present
onM2.
Henceforth, aj and bj will be used also as the
“names” of the two operations of job j. From the context, it will be clear whether aj and bj refer
the name of an operation or its processing time.
In this problem, the no-wait constraint species that operation aj must nish at least cj time units after
operationbjstarts, and at mostdjtime units after
op-eration bj starts. It will become clear later that the
setup times of jobs on machineM1need not be
consid-ered explicitly. Since the nish of operationaj
over-laps the execution of operationbj, it is evident that
the only feasible schedules are permutation schedules, i.e., schedules in which the jobs are identically ordered on machinesM1andM2. The objective is to minimize
the makespanCmax, which is the time from the start
of processing of the rst job in the schedule until the completion of processing of the last job in the sched-ule. We assume henceforth that processing starts at time zero, so thatCmax is the completion time of the
last job to be processed.
In the case that cj =dj = 0 for j∈N, the
prob-lem becomes a pure two-machine no-wait ow shop problem, which we denote by F2|no-wait|Cmax in
the notation of Graham et al. [7], and Gilmore and Gomory [4] provide an O(nlogn) algorithm (see Gomory et al. [5] for details of the implementa-tion). In the case thatcj=dj¿0 forj∈N, Gupta
et al. [8] presents an O(nlogn) algorithm to nd an optimal schedule. Their algorithm, modies the processing time of each job j on machines M1 and
M2 to max{aj−cj;0} andbj−cj, respectively, and
solves the resulting F2|no-wait|Cmax problem by
the algorithm of Gilmore and Gomory.
Inno-waitscheduling, a job must leave a machine
immediately after processing is completed. The less restrictive case, which is known asblocking, permits a job to remain on the current machine after process-ing if the next machine is busy, but no other job can be processed on the current machine while the job is still present. We refer to the survey of Hall and Sriskandarajah [9] for a detailed classication of the complexity of blocking problems. In our prob-lem scenario, it is easy to see that for the case
cj = 0 for j∈N, both no-wait and blocking
prob-lems in the two-machine ow shop are equiva-lent. Moreover, both problems are shown to be NP-hard by Logendran and Sriskandarajah [11] for the case cj = 0 for j∈N. Thus, it is unlikely
that the general problem can be solved by an e-cient optimal algorithm [3]. Rock [13] shows that the three-machine problem (F3|no-wait|Cmax) is
In this paper, we propose an ecient approxima-tion algorithm that nds a heuristic schedule for prob-lemF2|no-wait; setup{cj; dj} |Cmaxby applying the
Gilmore–Gomory algorithm to sequence the jobs. We establish that the makespan of the heuristic sched-ule is no more than 43 times the optimal makespan, and that this bound is tight. Therefore, theworst-case
performance ratioof our heuristic is 43.
3. Transformations
In this section, we show how an instance of problem
F2|no-wait; setup{cj; dj} |Cmax can be transformed
so that
06cj6dj6min{aj; bj}; (1)
without aecting the optimal makespan. Before deriv-ing the transformation, we introduce some properties of feasible and optimal schedules.
A schedule={(S(aj); S(bj))|j∈N}is given by
the set of start time vectors for the n jobs, where
S(o) denotes the start time of operationo. LetC(aj)
=S(aj) +ajandC(bj) =S(bj) +bj denote the
com-pletion times of operationsajandbj, respectively. For
each job j(j∈N), a feasible schedule satises the
Condition (3) is the operation overlap constraint, while condition (4) ensures that no two jobs are processed by a machine at the same time.
We may also denote a schedule by its set of com-pletion times={(C(aj); C(bj))|j∈N}. Theand representations are obviously equivalent. Thus, we may restate our problem: nd a feasible schedule which minimizesCmax= maxj∈NC(bj).
Two observations will be useful during the devel-opment of our heuristic algorithm.
Observation 1.In a feasible schedule, ifS(bj)¡S(aj),
then M1 is idle over the period (S(bj); S(aj)). This
holds because the processing of operationbj cannot
overlap with the processing of operationai of a
pre-ceding jobisinceC(ai)6S(bi) +di6C(bi)6S(bj).
Observation 2. The early start schedule for any
given ordering of the jobs places each operation as early as possible, subject to the ordering and the fea-sibility conditions. The early start schedule yields the minimum makespan among schedules that respect the given ordering.
Theorem 1. Let unprimed (primed) expressions
re-fer to the unprimed(primed)instances. The two
prob-lem instances I ={(aj; bj; cj; dj)|j∈N} and I′ =
Proof. For instanceI′
to be well dened, we require that c′
inequalities holds. Further,d′
j= min{a
′
j; dj}6dj, and dj6bjfrom instanceI, which establishes the second
inequality. Therefore,I′
is a valid instance. It suces to show that there is at least one optimal schedule
={(C(aj); C(bj))|j∈N} for I which is feasible
forI′, sinceI′ is a more constrained instance.
Assume that is an optimal early start schedule for instance I. Consider the schedule ′
= for in-stanceI′
in which operations a′
j andb
′
j are assigned
the same completion times of C′
(a′
for all jobsj. Therefore, machineM2processes
opera-tionb′
jin schedule′for instanceI′in the same period
as operation bj in schedule for instance I. Hence,
it is sucient to consider machineM1 when
check-ing that no operations on the same machine overlap in schedule′
. To establish feasibility of schedule′
for instanceI′
of generality, we assume thatsequences jobs in the
the rst inequality is obtained from the feasibility con-dition (3) of schedulefor instanceI.
Part2:S′(
b′
j) +c′j6C′(a′j)6S′(b′j) +d′jfor each
job j. To establish the left-hand inequality, we note thatS′(b′
j) +c′j=S(bj) +cj6C(aj), where the
equa-tion is obtained from (6) and the deniequa-tion ofc′
j, and
the inequality is obtained from (3) using the feasi-bility of schedule for instance I. Since we have
C′
(a′
j) =C(aj), the desired inequality is established.
For the right-hand inequality, three alternative cases are considered for each jobj(j∈N).
Case 1: aj6cj. In this case, a′j =cj, and since cj6dj, we have d′j=cj. Since is an earliest start
time schedule for instance I, and aj6cj,
Observa-tion 1 shows that machine M2 dictates when job j
is scheduled. Specically, operation bj starts
im-mediately after machine M2 completes its previous
operation (or at time zero if there is no previous operation), and operationajis scheduled to complete
at timeC(aj) =S(bj) +cj. Hence,C′(a′j) =C(aj) = S(bj) +cj=S′(b′j) +d′j, where the nal equality is
obtained from (6) and our knowledge thatd′
j=cj.
Case 2: cj¡ aj6dj. In this case, a′j =d
′
j =aj.
We claim that S(aj)6S(bj) because is an
earli-est start time schedule for instance I. To justify our claim, we note that if S(aj)¿ S(bj), then
Observa-tion 1 shows that operaObserva-tion aj could be scheduled
earlier than in schedule without aecting feasibil-ity. Thus, C(aj) =S(aj) + aj6S(bj) +aj. Hence,
last equation is obtained from (6) and our knowledge thatd′
j=aj.
Case3:cj6dj¡ aj. In this case,aj′=ajandd′j=dj.
We obtainC′(a′
j) =C(aj)6S(bj) +dj=S′(b′j) +d′j,
where the inequality is obtained from (3) using the feasibility of schedule for instance I, and the last equation is obtained from (6) and our knowledge that
d′
j=dj.
We have now established the desired inequalities for Part 2 in all three cases.
Part 3: Operation a′
j does not overlap with
operation a′
j−1 except perhaps at its end point,
i.e., (S′
operationsaj anda′j occupy the same time intervals
in schedules and′
, respectively, and therefore no overlap is created on machineM1in schedule′. Now
assume that aj¡ cj. As observed in Case 1 above, C(aj) =S(bj) +cj. Further, Observation 1 shows that
schedule leaves machine M1 idle over the interval
(S(bj); S(aj)), an interval of lengthS(aj)−S(bj) =
For the instanceI′ of Theorem 1, the proof
estab-lishes thatI′ is a valid instance by establishing the
in-equalitiesc′
1, we may restrict our attention to instances of this type.
For simplicity of notation, we use unprimed nota-tion henceforth, and restrict our attennota-tion to instances for which (1) holds.
4. Heuristic algorithm
Because we are considering instances withdj6aj,
it follows thatS(aj)6S(bj) for each jobj(j∈N) in
any feasible solution. The no-wait constraint requires operationsajandbjtooverlapby at leastcjtime units,
but no more thandj time units. Suppose we were to
impose a xed overlap of sizejfor each jobj, where cj6j6dj. These xed overlaps would imply that
C(aj) =S(bj) +j: (7)
in any schedule that we consider. This is equivalent to changing the parameters of the problem so that
cj=dj=j for j∈N. Hence, it is obvious that the
For a given set of overlaps ={1; : : : ; n}, a
sched-ule can be obtained using the following algorithm. We then provide a justication that the algorithm gener-ates a schedule with minimum makespan.
Algorithm A
Step1: Dene an instance I forF2|no-wait|Cmax
by the data set{( aj;bj)|j∈N}, where aj=aj−j
and bj=bj−j.
Step2: Solve the instance of problemF2|no-wait|
Cmaxthat is dened in Step 1. Let the optimal schedule
be given by ={( S( aj);S( bj)|j∈N}. Without loss
of generality, assume that the jobs are processed in the order (1; : : : ; n) in .
Theorem 2. Given a set of overlaps ; a schedule
that has the minimum makespan among schedules
for which(7)holds forj∈N can be obtained using
AlgorithmA.
Proof. There is a one-to-one correspondence between
feasible solutions for which (7) holds for j∈N and feasible solutions to the no-wait problem given in Step 1 of Algorithm A in which the overlapjis
re-moved from each operationajandbj. The
correspon-dence is given by the relationship specied in Step 3. The dierence in values of the makespan for corre-sponding solutions is equal to the constant Pnj=1j,
from which the result follows.
We propose two alternative choices forjforj∈N.
To obtain the largest overlaps, we set
j=dj; (8)
whereas to avoid large deviations of the selected over-laps from their optimal values, we set
j= (cj+dj)=2: (9)
We denote the algorithms that apply Algorithm A us-ing the overlaps specied in Eqs. (8) and (9) by H1 and H2, respectively.
We now provide upper bounds on the worst-case performance of Algorithms H1 and H2. Let CH1
max
andCH2
maxdenote the makespans obtained by applying
Fig. 1. Overlap of operations.
Algorithms H1 and H2, respectively, and let C∗
max
denote the optimal makespan. Moreover, let
LB = max
denote the trivial lower bound on the makespan of any schedule.
Lemma 1. Algorithm H1 produces a schedule for
whichCmaxH162LB−
Pn j=1dj.
Proof. Sinceaj¿dj, by settingj=djforj∈N,
Al-gorithm H1 imposes an overlap of lengthdj between
operationsajandbj, as shown in Fig. 1. Since
Algo-rithm A constructs a schedule in which at least one machine is always busy, we have
CmaxH16
Substituting (10) provides the desired result.
Lemma 2. Algorithm H2 produces a schedule for
whichCH2
max6Cmax∗ + Pn
j=1dj=2.
Proof. It suces to show that there exists a feasible
solution ′
for the problem constrained by overlaps
j= (cj+dj)=2 for j∈N such that the
Fig. 2. Illustration ofj whenj¡0.
We nd ′ by perturbing iteratively using the
following procedure.
Procedure Perturb. SetS′
(aj) =S(aj) andS′(bj) =
all operations on machineM2 to the right ofbj+1 are
moved|j|time units to the right. It is easy to see that
feasibility for the original problem I is maintained, and that the transformation in thejth iteration yields a schedule withC(aj) =S(bj) + (cj+dj)=2. A similar
argument holds for the case ofj¿0 (see Fig. 3).
Hence, when the procedure is complete, a feasi-ble schedule for instance I is found for which the overlaps are dened by j = (cj+dj)=2 for j∈N.
Moreover, no operation is moved to the right more thanPnj=1|j|. Therefore, we deduce from
inequal-rithm H2 generates an optimal schedule for overlaps
j = (cj+dj)=2, we have CmaxH26C
′
max, from which
the desired result follows.
Fig. 3. Illustration ofj whenj¿0.
The worst-case performance bounds given in Lemmas 1 and 2 for Heuristics H1 and H2 are de-creasing and inde-creasing inPnj=1dj, respectively. For Pn
j=1dj¿ 2
3LB, Lemma 1 shows that
CmaxH1643LB643C∗
Thus, we propose the following heuristic algorithm for problemF2|no-wait;setup{cj; dj} |Cmax.
Step1. Compute the lower bound
LB = max
Selectj forj∈N from the following cases.
Case A: IfPnj=1dj¿23LB, setj=dj forj∈N.
Case B: IfPnj=1dj¡23LB, setj= (cj+dj)=2 for
j∈N.
Step2. Apply Algorithm A to the problem resulting from Step 1 to obtain a schedule.
Step3. Compute the early start schedule ˜for this ordering, and evaluate the resulting makespanCH
max.
Step4. Terminate.
Table 1
Data dening worst-case example for Case A
j 1 2 3 4 5 6
aj 0 1 2 3 4 5
bj 1 2 3 4 5 0
cj 0 0 0 0 0 0
dj 0 1 2 3 4 0
Fig. 4. Case A: optimal schedule,C∗
max= 15.
We now present the main result in this section.
Theorem 3. Algorithm H produces a schedule for
whichCH
max643C
∗
maxinO(nlogn)time.
Proof. The worst-case performance bound of
Algo-rithm H is obtained from inequalities (12) and (13). The complexity of Algorithm H is governed by the time requirement for solving problem
F2|no-wait|Cmax in Step 2 of Algorithm A, which
is applied once during execution of Algorithm H. The implementation of Gilmore, Lawler and Shmoys [5] of the algorithm of Gilmore and Gomory [4] solves problemF2|no-wait|Cmaxin O(nlogn) time,
which is the time complexity of Algorithm H. Note that pre-processing to convert an arbitrary instance to one satisfying 06cj6dj6min{aj; bj} requires
only O(n) time, and hence does not aect the overall complexity.
5. Worst-case examples
In this section, we provide worst-case examples for both Cases A and B from Step 1 of Algorithm H. Note that in Case A, we have an instance for which
CmaxH =Cmax∗ =1915= 1:266¡ 4
3, whereas for Case B the
worst-case instance shows that the bound of Theorem 3 is tight.
Worst-case example for Case A:n= 6
The instance is dened by the data in Table 1. The optimal schedule for this example (using the job sequence (1;2;3;4;5;6)) is shown in Fig. 4. In
Fig. 5. Case A: schedule at Step 2 of Algorithm H.
Fig. 6. Case A: worst-case schedule,CH max= 19.
Fig. 7. Case B: optimal schedule,C∗
max= 3k+ 1.
Fig. 8. Case B: schedule at Step 2 of Algorithm H.
Fig. 9. Case B: worst-case schedule,CH max= 4k. Table 2
Data constructed by Algorithm A for Case A
j 1 2 3 4 5 6
a′
j 0 0 0 0 0 5
b′
j 1 1 1 1 1 0
Figs. 4 –9, numbers in the activity blocks represent processing times, not job numbers. The optimal makespan is C∗
max = 15. Note that LB = 15 and Pn
Table 3
Data dening worst-case example for Case B
j 1 · · · k k+ 1 · · · 2k 2k+ 1 2k+ 2
aj 3 · · · 3 0 · · · 0 0 1
bj 2 · · · 2 1 · · · 1 1 0
cj 0 · · · 0 0 · · · 0 0 0
dj 2 · · · 2 0 · · · 0 0 0
Table 4
Data constructed by Algorithm A for Case B
j 1 · · · k k+ 1 · · · 2k 2k+ 1 2k+ 2
a′
j 2 · · · 2 0 · · · 0 0 1
b′
j 1 · · · 1 1 · · · 1 1 0
(Step 1 of Algorithm A), the data for the resulting
F2|no-wait|Cmax problem is shown in Table 2.
One possible schedule obtained by applying the Gilmore–Gomory algorithm of Gilmore and Gomory [4] to the data of Table 2 is shown in Fig. 5, where
is dened by the job sequence (1;6;2;3;4;5). The early start schedule for job order is obtained in Step 3 of Algorithm H, and is shown in Fig. 6. The makespan of the schedule isCH
max= 19. Thus, we have
CH max=C
∗
max=1915= 1:266¡1:333.
Worst-case example for case B:n= 2k+ 2
The instance is dened by the data in Table 3. An optimal schedule for this example is given in Fig. 7 and the optimal makespan isC∗
max= 3k+ 1.
Note that LB = 3k+ 1 andPNj=1dj= 2k ¡23LB. In
Step 2 of Algorithm H (Step 1 of Algorithm A), the data for the resulting F2| no-wait |Cmax problem is
shown in Table 4.
One possible schedule (given by sequence (2k+ 1;2k+ 2;2k;1; : : : ;2k−1)) obtained by applying the Gilmore–Gomory algorithm to the data of Table 3 is shown in Fig. 8. The early start schedule obtained in Step 3 of Algorithm H is shown in Fig. 9, and the makespan isCH
max= 4k. Thus, we haveCmaxH =Cmax∗ =
4k=(3k+ 1), which can be arbitrarily close to 4 3.
6. Worst-case performance ratio
Theorem 3 establishes that Algorithm H generates a schedule for which CH
max=C
∗
max643. The worst-case
example in Section 5 for Case B shows that this bound is tight. Therefore, the worst-case performance ratio of Algorithm H is 43.
The worst-case example for Case A is not tight, which indicates that there may be scope for modifying Heuristic H to improve its worst-case performance. Specically, rather than dierentiating between Cases A and B by comparing Pnj=1dj with fLB, where f=23. An alternative fraction could be used. However, we claim that no modication of this type can lead to a worst-case performance ratio of less than 1.3. To justify this claim, we note that Lemma 2 and inequality (13) yield
CmaxH2 6C∗
max+
1 2
n X
j=1
dj6Cmax∗ +
f
2LB
6(1 +f=2)C∗
max
and worst-case examples show that this bound is tight. Moreover, forf ¡0:6, an example for Case A shows that the worst-case performance ratio is at least 1.3. Thus, our claim is established.
Acknowledgements
This research was supported in part by the Natural Sciences and Engineering Research Council of Canada (Grants numbers OGP0002507 and OGP0104900), and by NATO (Collaborative Research Grant No. CRG 950773).
References
[2] B. Chen, C.N. Potts, G. Woeginger, A review of machine scheduling: complexity, algorithms and approximability, in: D.-Z. Du, P.M. Pardalos (Eds.), Handbook of Combinatorial Optimization, Vol. 3, Kluwer, Dordrecht, 1998, pp. 21–169. [3] M.R. Garey, D.S. Johnson, Computers and Intractability: A Guide to the Theory of NP-Completeness, Freeman, San Francisco, 1979.
[4] P.C. Gilmore, R.E. Gomory, Sequencing a one state-variable machine: a solvable case of the travelling salesman problem, Oper. Res. 12 (1964) 655–679.
[5] P.C. Gilmore, E.L. Lawler, D.B. Shmoys, Well-solved special cases, in: E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, D.B. Shmoys (Eds.), The Travelling Salesman Problem: A Guided Tour of Combinatorial Optimization, Wiley, Chichester, UK, 1985, pp. 87–143.
[6] S.K. Goyal, C. Sriskandarajah, No-wait shop scheduling: computational complexity and approximate algorithms, Opsearch 25 (1988) 220–244.
[7] R.L. Graham, E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, Optimization and approximation in deterministic
sequencing and scheduling: a survey, Ann. Discrete Math. 5 (1979) 287–326.
[8] J.N.D. Gupta, V.A. Strusevich, C.M. Zwaneveld, Two-stage no-wait scheduling models with setup and removal times separated, Comput. Oper. Res. 24 (1997) 1025–1031. [9] N.G. Hall, C. Sriskandarajah, A survey of machine scheduling
problems with blocking and no-wait in process, Oper. Res. 44 (1996) 510–525.
[10] E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, D.B. Shmoys, Sequencing and scheduling: algorithms and complexity, Report BS-R8909, Center for Mathematics and Computer Science, Amsterdam, The Netherlands, 1989. [11] R. Logendran, C. Sriskandarajah, Two-machine group
scheduling problem with blocking and anticipatory setups, Eur. J. Oper. Res. 69 (1993) 467–481.
[12] M. Pinedo, Scheduling Theory, Algorithms, and Systems, Prentice-Hall, NJ, 1995.
