European Journal of Operational Research 123 (2000) 229240

www.elsevier.com/locate/orms

Heuristics for the two-stage job shop scheduling problem with a

bottleneck machine
I.G. Drobouchevitch, V.A. Strusevich

School of Computing and Mathematical Sciences, University of Greenwich, Maritime Greenwich University Campus, 30 Park Row,
London SE10 9LS, UK

Abstract
The paper considers the job shop scheduling problem to minimize the makespan. It is assumed that each job consists
of at most two operations, one of which is to be processed on one of m P 2 machines, while the other operation must be
performed on a single bottleneck machine, the same for all jobs. For this strongly NP-hard problem we present two
heuristics with improved worst-case performance. One of them guarantees a worst-case performance ratio of 3=2. The
other algorithm creates a schedule with the makespan that exceeds the largest machine workload by at most the length
of the largest operation. 2000 Elsevier Science B.V. All rights reserved.
Keywords: Job shop scheduling; Approximation algorithm; Worst-case analysis

1. Introduction
In the general job shop scheduling model, each
job consists of several operations to be processed
on all or some of the given machines. The operations of a job have to follow the assigned processing route, specic for each job. In such a route,
some of the machines may be skipped, while the
others may appear more than once. If all jobs have
the same processing route, the model is called the
ow shop. Given the processing times of all oper-

*
Corresponding author. Tel.: +44-181-331-8662; fax: +44181-331-8665.
E-mail address: v.strusevich@greenwich.ac.uk (V.A. Strusevich).

ations, a purpose is to nd a schedule that minimizes a certain objective function. In all problems
considered in this paper the objective function to
be minimized is the makespan, i.e., the maximum
completion time of all jobs on all machines.
It is often found in practice that the processing
routes may be short, e.g., consist of two or three
operations each. (See [6,8,14] for a discussion of
various applications of the two-stage shop scheduling problems.)
In this paper we consider the job shop scheduling problem in which the processing route for
each job consists of two operations at most.
Moreover, in our model the number of machines is
arbitrary, and one of the operations of each job
has to be processed on a particular machine, the
same for all jobs. We call such a machine the

0377-2217/00/$ - see front matter 2000 Elsevier Science B.V. All rights reserved.
PII: S 0 3 7 7 - 2 2 1 7 ( 9 9 ) 0 0 2 5 3 - 2

230

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

bottleneck machine. In many applications the

bottleneck machine can be seen as an input/output
bay, where the orders arrive to be further fullled
or where the completed orders are gathered before
shipped to the customer.
The model under consideration is closely
related to some other scheduling problems known
in the literature, such as the two-stage ow shop
problem with parallel machines in one stage [1,12]
and the two-stage assembly scheduling problem
[15]. For these and similar shop scheduling problems, research has recently been focused on developing and analyzing approximation algorithms.
Because of their relative simplicity, these models
have appeared to be helpful for testing various
scheduling techniques. On the other hand, even the
short route problems are not straightforward to
solve. It is known that for the job shop with three
operations per job nding a schedule close to an
optimal one is no easier than solving the problem
to optimality [19].
In this paper we extend the approximation
results obtained in [6,8,13,14], where the ow shop
counterpart of our problem is studied. Our algorithms not only handle a more general job shop
problem, but also guarantee a better performance
than heuristics known for the ow shop.
The remainder of the paper is organized as
follows. Section 2 gives a formal description of the
problem. Section 3 briey overviews the relevant
results in the area. In Section 4 we study properties
of the job shop schedules with the bottleneck
machine. In Section 5 we present an algorithm that
creates a schedule with the makespan that is no
more than 3/2 times the optimal value. Section 6
shows how to nd a schedule with the makespan
that exceeds the largest machine workload by at
most the length of the largest operation.
2. Problem description
We start with a formal description of the job
shop. We are given m machines and a set of n jobs,
where job j consists of mj operations. Each operation has to be processed on a specied machine.
The processing times of all operations are known.
For each job, the order in which its operations

must be processed is known in advance, and can be

dierent for dierent jobs. There is no preemption
in processing an operation. The usual scheduling
requirement says that no two jobs may be processed on a machine at a time, and each job may
not be assigned to more than one machine at a
time. For a schedule S the value of the makespan is
denoted by Cmax S.
To refer to a particular scheduling problem we
follow a standard three-eld notation as in [11]. If
the number of machines is variable, the job shop
problem is denoted by J jjCmax . If the number of
machines m is xed and the length of any route
does not exceed a given value of m0 , then the
problem is denoted by Jmjmj 6 m0 jCmax . The
J 2jmj 6 2jCmax problem is solvable in On log n
time [9].
If for each job the processing route is the same
and no machine is visited twice, we obtain the ow
shop problem traditionally denoted by F jjCmax .
The well-known Johnson algorithm solves the
F 2jjCmax problem in On log n time. The F 3jjCmax
problem is strongly NP-hard as proved in [4].
We now formally describe the two-stage job
shop scheduling problem with a single bottleneck
machine, which is the main subject of this study.
We are given m 1 machines, m P 2; denoted by
A1 ; A2 ; . . . ; Am and B. Each job j consists of at most
two operations, one of which is processed on the
bottleneck machine B: For each machine Ak , we
are given a set Nk that consists of all jobs that are
rst processed on Ak and then on B; in other
words, all jobs of Nk are given the processing route
Ak ; B. Similarly, for Ak we are given a set Hk of all
jobs that must follow the opposite route B; Ak . In
any case, for a job j 2 Nk [ Hk its processing on
machine Ak takes aj time units, while the processing time on the bottleneck machine B is equal to
B can
bj . The jobs to be processed on machine
Sm
be grouped
into
two
sets
N

N
and
k
k1
Sm
H k1 Hk with jN j n and jH j h:
We will denote the problem of minimizing the
makespan for the described processing system by
J m 1jmj 6 2jCmax . If all jobs have the same
route, e.g., if H ;, the resulting ow shop
problem is denoted by F m 1jmj 6 2jCmax . As
shown in [8,13], the F m 1jmj 6 2jCmax problem
is NP-hard in the strong sense if m 2. This

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

implies the same complexity status of the corresponding job shop problem J m 1jmj 6 2jCmax
for m P 2.
In the F m 1jmj 6 2jCmax problem a job j has
to be processed rst on a particular machine Ak : If,
otherwise, each job j may be processed on any of
the machines A1 ; A2 ; . . . ; Am and this still takes aj
time, we obtain the two-stage ow shop problem
with m identical parallel machines in the rst stage
[1]. On the other hand, the F m 1jmj 6 2jCmax
problem is a special case of the two-stage assembly
problem, provided that B is the assembly machine
and each job has to be processed on exactly one
machine in the rst stage [15].
Since the J m 1jmj 6 2jCmax problem and
most of the relevant problems are NP-hard, nding an optimal solution in reasonable computation
time is highly unlikely. This initiates the search for
fast approximation algorithms that may nd a
schedule close to an optimal one. Section 3 gives a
brief overview of the results in this area.
3. Review of shop approximation
For a schedule created by an approximation
algorithm it is desirable to be able to know in
advance how close to the optimum that schedule
appears to be. The quality of S is usually measured
by the ratio Cmax S=Cmax S  or by the dierence
Cmax S Cmax S  , where S  is an optimal schedule for the given problem instance.
An algorithm H that creates a schedule SH is
called a q-approximation algorithm if the inequality
Cmax SH =Cmax S  6 q holds for all problem instances. The smallest possible value of q is called
the worst-case performance ratio of the algorithm.
As shown by Hall [7], the FmjjCmax problem
admits a polynomial-time approximation scheme
(PTAS), i.e., there exists a q-approximation algorithm with q 1 e for any given e > 0, and the
running time of such an algorithm is polynomial
for xed m and e. This approach cannot be extended for the general JmjjCmax problem. However,
a similar argument carries over for the
J m 1jmj 6 2jCmax problem because of its specic features. Therefore, it can be concluded that
the J m 1jmj 6 2jCmax problem admits a PTAS,

231

though its running time appears highly impractical. On the other hand, even the F m 1jmj 6
2jCmax problem with m 2 does not allow a fully
polynomial approximation scheme (unless P
NP), since the problem is strongly NP-hard.
Recall that an approximation scheme is called fully
polynomial if q 1 e for any given e > 0, and
the running time is polynomial in both the length
of the problem input and 1=e.
For the JmjjCmax problem a schedule Se such
that
Cmax Se
62 e
Cmax S 
holds for any given e > 0, can be found in time
that is polynomial for xed m and 1=e [18]. This
result and the PTAS mentioned above produce
important theoretical evidence of the existence of
polynomial algorithms with small values of q. On
the other hand, Williamson et al. [19] show that,
unless P NP, there is no polynomial time algorithm for the F jjCmax problem which provides
q < 5=4. Notice that the latter result only holds if
the instance of the problem contains a job with at
least three operations.
For the FmjjCmax and Jmjmj 6 m0 jCmax problems,
heuristic algorithms that require reasonable computational eort are not known to provide even a
constant worst-case performance ratio q [5]. For
F 3jjCmax problem, a 5=3-approximation algorithm
is developed in [2]. For each of the J 3jmj 6 2jCmax
and J 2jmj 6 3jCmax problems, 3=2-approximation
algorithms are oered in [3].
For the two-stage assembly problem with m
machines in the rst stage, Potts et al. [15] give a
number of heuristics the best of which yields
q 2 1=m: The same ratio is known for the twostage ow shop problem with at most m parallel
machines in a stage [12] .
For the F m 1jmj 6 2jCmax problem with
m 2, algorithms with q 3=2 are described in
[8,14]. That result is extended by Gupta [6], who
designs several heuristic algorithms that provide
q 2 1=m for the F m 1jmj 6 2jCmax problem. In this paper, we give a 3=2-approximation
algorithm for the general J m 1jmj 6 2jCmax
problem.

232

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

For a shop scheduling problem, let P  denote

the largest machine workload, i.e., the sum of the
processing times of all operations assigned to the
machine. The length of the largest operation is
denoted by pmax . For various shop scheduling
problems, there are heuristic algorithms that create
schedule SH such that Cmax SH 6 P  apmax . Observe that the value apmax can be considered as a
bound on the absolute error Cmax SH Cmax S  ,
since Cmax S  P P  . This also implies that
Cmax S  2 P  ; P  apmax :

Given a scheduling problem, it is an interesting

research goal to nd the smallest value of a for
which (1) holds. Most of the results in this direction belong to Sevast'janov and usually employ
geometric methods, such as compact vector summation. See [16,17] for the recent developments in
this area.
In this paper, we show how to nd a schedule S
for the J m 1jmj 6 2jCmax problem such that
Cmax S 6 P  pmax . This extends an analogous
result established for the F m 1jmj 6 2jCmax
problem with m 2 [13].

4. Finding job shop schedules

In this section we present algorithms for the
ow shop and job shop scheduling problems with
a single bottleneck machine. The algorithms provide the basis for our heuristics introduced in the
subsequent sections. The algorithms employ the
idea of greedy scheduling on the bottleneck
machine.
Given the J m 1jmj 6 2jCmax problem, we
distinguish between the operations of a job, referring to them as the rst-stage operation and the
second-stage operation, respectively. Thus, for a
job of some set Nk ; its rst-stage operation is performed on machine Ak ; while its second-stage operation is done on the bottleneck machine. For the
jobs of a set Hk the operations are classied analogously.
For our purposes, we may restrict our attention
to the schedules with the following structural
properties:

(i) Every machine Ak ; 1 6 k 6 m; rst processes

all jobs of set Nk followed by all jobs of set Hk :
(ii) The bottleneck machine starts with all jobs
of set H followed by all jobs of set N.
(iii) On each machine the rst-stage operations
may start at time zero and be processed as a
block, with no intermediate idle time.
(iv) For the jobs of each set Nk or Hk ; the rststage operations and the second-stage operations follow the same sequence.
Due to standard interchange argument, any
schedule can be converted into the one of the required structure without increasing the makespan.
For an non-empty set Q  N [ H we dene
aQ

X
j2Q

aj ;

bQ

bj ;

j2Q

assuming that a; b; 0: For a schedule S,

the starting time and the completion time of a job
j on a machine Ak are denoted by Rj;A S and
Cj;A S, respectively. For the bottleneck machine,
similar values are denoted by Rj;B S and Cj;B S,
respectively. If no confusion arises, we may drop
the reference to the schedule and write Rj;A or Cj;B .
We now concentrate on the ow shop
F m 1jmj 6 2jCmax problem of scheduling the
jobs of set N only. Let uk Nk denote a given sequence of jobs of set Nk on machine Ak . Our current purpose is to describe an algorithm that takes
these sequences as an input and nds a feasible
schedule satisfying the above properties. What
needs to be determined is the sequence uN of all
operations and their starting times (or completion
times) on the bottleneck machine.
Consider a feasible ow shop schedule S 0 that is
terminated on machine B. Assume that there is no
unforced idle time on B, i.e., machine B is idle if
and only if there is no job that may be started on
it. There exists a job w such that:
(a) the second-stage operation of w starts exactly at time its rst-stage operation completes, i.e.,
Cw;A S 0 Rw;B S 0 ;
(b) job w is the rst job in the sequence uN
after which machine B has no idle time.
Job w is called critical. We cannot increase the
starting time Rw;B S 0 of the critical job without
increasing the makespan, as long as the sequence

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

uN is kept. For our purposes, it is convenient to

transform S 0 into another schedule S with
Rw;B S Rw;B S 0 and with the same makespan by
letting all jobs that precede job w in uN start on
B as late as possible. In the resulting schedule S,
the sequence uN of jobs starts on B at time
RB S Cmax S bN and the jobs are processed
as a block, without intermediate idle time.
The algorithm presented below nds a ow
shop schedule S, which is the best of all feasible
schedules associated with a given collection of the
sequences of the rst-stage operations.

233

on machine Ak according to a given sequence

wk Hk . Algorithm FSN can be modied to nd
the best schedule among those associated with the
given permutations.

Algorithm FSN. Input: An instance of the

F m 1jmj 6 2jCmax problem and the sequences
u1 N1 , u2 N2 ; . . . ; um Nm .
Output: Feasible schedule S.
1. For each machine Ak start the sequence uk Nk
at time zero and process the jobs of Nk as a
block, with no intermediate idle time.
2. Scanning the jobs in the order they are completed in the rst stage, nd schedule S 0 by starting
the processing of the next available job on machine B as early as possible, until all jobs are
scheduled. Call the resulting sequence uN .
Compute the value of the makespan Cmax S 0
as the completion time of the last job in uN
on machine B.
3. Compute Y B S Cmax S 0 bN . In the
found schedule S, the sequence uN of jobs
starts on B at time Y B S; machine B has no intermediate idle time and Cmax S Cmax S 0 :

Algorithm FSH. Input: An instance of the ow

shop problem for processing the jobs of set H and
a collection of the sequences w1 H1 , w2 H2 ; . . . ;
wm Hm .
Output: Feasible schedule S.
1. For each k; 1 6 k 6 m; nd the permutation
e Hk obtained by inverting the order of jobs
w
k
in the permutation wk Hk . Introduce the articial F m 1jmj 6 2jCmax problem with the set
of jobs H, assuming that for all these jobs the
second-stage operation is processed on the bottleneck machine B.
2. Run Algorithm FSN for the obtained
e Hk ;
F m 1jmj 6 2jCmax problem with w
k
e
k 1; 2; . . . ; m. Let S be the found schedule in
which machine B processes the jobs of H in
e :
the sequence wH
3. Find the permutation wH by taking the jobs
e in the opposite order. Transform e
in wH
S into a feasible schedule S for the original problem
S Cmax S. In
by inverting time, so that Cmax e
the found schedule S, the jobs of set H start on
B at time zero and follow the sequence wH ,
while each of the machines Ak starts at time
S aHk and processes the jobs
YkA S Cmax e
of set Hk in the sequence wk Hk with no intermediate idle time.

Let w be the critical job in schedule S 0 . It is clear

that w remains critical in S, and Rw;B S Rw;B S 0 .
Algorithm FSN assigns the jobs to machine B in
the greedy manner. In any feasible schedule associated with a given collection of the permutations
u1 N1 , u2 N2 ; . . . ; um Nm , neither job w nor any
of the jobs that follow w in the sequence uN may
start on B earlier than time Rw;B S. Therefore, the
found schedule S provides the smallest makespan
among all ow shop schedules related to the permutations u1 N1 , u2 N2 ; . . . ; um Nm :
We now pass to the ow shop problem of
processing the jobs of set H, that is symmetric to
the one considered above. For each k, 1 6 k 6 m;
assume that the jobs of set Hk have to be processed

We now turn to the original J m 1jmj 6

2jCmax problem. Notice that the problem can be
viewed as two independent ow shop problems
with the same bottleneck machine: one for processing the jobs of set N, and the other for processing the jobs in H. For each k, 1 6 k 6 m;
assume that for machine Ak the jobs of set Nk must
follow a given sequence uk Nk , while the jobs of
set Hk have to be processed according to a given
sequence wk Hk . We describe how the ow shop
schedules found by Algorithm FSN and Algorithm FSH can be combined together to produce
the desired job shop schedule. If the direct superposition of the two schedules produces clashes,
i.e., on some machine the rst-stage operations

234

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

complete later that the second-stage operations

start, then we nd the longest interval of such an
overlap and shift the conicting second-stage
operations to the right.
Algorithm JS. Input: An instance of the
J m 1jmj 6 2jCmax problem and two collections
of the sequences u1 N1 , u2 N2 ; . . . ; um Nm and
w1 H1 , w2 H2 ; . . . ; wm Hm .
Output: Feasible schedule S.
1. Run Algorithm FSN for the ow shop problem
with the set of jobs N. Let SN be the found
schedule in which machine B starts processing
the jobs in set N at time Y B SN :
2. Run Algorithm FSH for the ow shop problem
with the set of jobs H. For the found schedule
SH , a machine Ak starts processing the jobs in
set Hk at time YkA SH ; k 1; 2; . . . ; m.
3. For each k; k 1; 2; . . . ; m; compute Dk
Compute
DB
max aNk YkA SH ; 0 .
max fbH Y B SN ; 0g:
4. In schedule SN ; increase the starting time of
each operation on machine B by DB . In schedule
SH ; increase the starting time of each operation
on every machine Ak by Dk . Combine the resulting schedules together to obtain the required
schedule S:
Notice that in schedule created by Algorithm JS
a machine for which the shifts in step 4 have been
made starts at time zero and has no intermediate
idle time. The value of the makespan of the resulting schedule either is equal to the workload of
some machine or is determined by the makespan
of one of the schedules SN or SH .
The running time of each of the Algorithms
FSN, FSH and JS is linear in the number of jobs.
5. Heuristic with ratio performance guarantee
In this section we present a heuristic algorithm
for the job shop problem with a single bottleneck
machine. We start with considering the ow shop
problem; the generalization of our approach to the
job shop is quite straightforward.
Most of heuristic algorithms for the
F m 1jmj 6 2jCmax problem use a certain ver-

sion of the articial F 2jjCmax problem and apply

the Johnson rule [10] to determine the sequences of
jobs on all machines, including the bottleneck
machine, (see e.g., [6]). Our algorithm for the ow
shop problem starts with an arbitrary schedule and
transforms it into another schedule with the
makespan that is at most 3/2 times the optimal
value.
Let S  be an optimal schedule for the
J m 1jmj 6 2jCmax problem. The so-called machine-based lower bound on the value of the
makespan is apparent:
Cmax S  P maxfaN1 [ H1 ; aN2 [ H2 ; . . . ;
aNm [ Hm ; bN [ H g:

For the F m 1jmj 6 2jCmax problem for processing the jobs of set N ; let an optimal schedule be
denoted by SN . In this case (2) becomes
Cmax SN P max faN1 ; aN2 ; . . . ; aNm ; bN g:
3
For a job u 2 N and for any set U 
fj j aj P au ; j 2 N g the lower bound
Cmax SN P au bU

holds, since in any feasible schedule no job of set U

can be started on B earlier than time au .
We now present an algorithm that creates a
ow shop schedule with the makespan that is at
most 3/2 times the optimal value.
Algorithm RG. Input: An instance of the
F m 1jmj 6 2jCmax problem with the set N of
jobs.
Output: Schedule SN .
1. For each k; 1 6 k 6 m; take an arbitrary permutation pk Nk of the jobs of set Nk . Run Algorithm FSN taking these permutations as the
input. Call the found schedule S0 :
2. In schedule S0 ; nd a critical job w and dene s
as the starting time of job w on machine B.
Dene the index set M 0 such that
M 0 fk j 1 6 k 6 m; aNk P sg:
3. For each k 2 M 0 do the following. Find the job
wk 2 Nk for which Rwk ;A S0 < s and Cwk ;A S0

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

P s: Find the set Nk0 of jobs, which precede job

wk in the sequence pk Nk : Dene Nk00 as the set
of jobs that follow job wk in the sequence
pk Nk .
4. For each k; 1 6 k 6 m; dene the sequence
rk Nk pk Nk00 ; pk Nk0 ; wk if k 2 M 0 ; otherwise dene rk Nk pk Nk . Run Algorithm
FSN taking these permutations as the input.
Call the found schedule S1 :
5. For each k; 1 6 k 6 m; dene the sequence
vk Nk wk ; pk Nk0 ; pk Nk00 if k 2 M 0 ; otherwise dene vk Nk pk Nk . Run Algorithm
FSN taking these permutations as the input.
Call the found schedule S2 :
6. Among the found schedules S0 ; S1 and S2 ; determine the one with the smallest value of the
makespan. Call this schedule SN . Output SN
and stop.
The running time of Algorithm RG does not
exceed an Onm. The theorem below analyses its
worst-case performance.
Theorem 1. Algorithm RG generates a schedule SN
for the F m 1jmj 6 2jCmax problem such that the
bound
Cmax SN 3
6
Cmax SN 2

holds and this bound can not be reduced.

Proof. We start with considering schedule S0 associated with an arbitrary collection of sequences
of the rst-stage operations. Schedule S0 is terminated on the bottleneck machine B. We assume
that the other machines are indexed in such a way
that
aN1 P aN2 P


P aNm :

Let w be the critical job in S0 ; and the processing of this job on machine B starts at time
Rw;B S0 s. We identify the largest index q such
that aNq P s; in other words M 0 f1; 2; . . . ; qg
(see step 2).
Let the jobs wk and the sets Nk0 and Nk00 ; k 2 M 0 ;
be dened as in step 3. Dene the sets

N 00

W fw1 ; w2 ; . . . ; wq g;

q
[

235

Nk00 ;

k1

N 0 N n N 00 [ W :

Notice that in schedule S0 the sequence of jobs

on B is found by Algorithm FSN. Because of the
greedy nature of that algorithm, any job that is
completed on a rst-stage machine by time s is also
completed on B by time s; otherwise, job w would
not be the critical job. This implies that machine B
after time s processes only the jobs of sets W and
N 00 . By denition of job wk ; we have that aNk0 < s
and aNk0 awk P s, which imply that


7
Cmax S0 6 aNk0 awk bW b N 00
is valid for each k 2 M 0 . Notice that for the critical
job wk w the relation above turns into the
equality.
If aNk0 awk 6 12 Cmax SN for some k 2 M 0 ,
then (7) gives (5) due to (3). Therefore, in the rest
of this proof we assume that
1
aNk0 awk > Cmax SN ;
2

k 2 M 0:

These inequalities and (3) imply that

1
a Nk00 < Cmax SN ;
2

k 2 M 0:

Consider now schedule S1 found in step 4, that

is associated with the collection of sequences
r1 N1 ; r2 N2 ; . . . ; rm Nm . Let x denote the critical job in schedule S1 .
For schedule S1 , suppose that for some r 2 M 0
there exists a job u 2 Nr00 that is started on B no
earlier than the critical job x. Recall that the index
set M 0 and the set Nr00 of jobs are dened with
respect to schedule S0 . Then


Cmax S1 6 Rx;B S1 bN 6 a Nr00 bN ;
which yields (5) due to (3) and (8). Therefore, we
assume that all jobs that start on B no earlier than
the critical job belong to the set W [ N 0 .
We show that the inequality
Cmax S1 6 aN1 bW

holds. For schedule S1 ; determine the set Q consisting of all jobs in N 0 that start on B no earlier

236

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

than the critical job. If Q ;, then (9) obviously

holds. Thus, we further assume that Q 6 ;.
In schedule S0 all jobs of set Q are completed on
B before time s. Find the job y, which is the rst
job of set Q to be processed on B in schedule S0 . It
follows that
Cy;A S0 bQ 6 s:
On the other hand, in schedule S1 job x is
critical and y starts on B no earlier than x. This
implies that Cy;A S1 P Cx;A S1 , so that
Cmax S1 6 Cy;A S1 bQ bW :
If job y belongs to set Nr0for
some r 2 M 0 , then
we obtain that Cy;A S1 a Nr00 Cy;A S0 ; otherwise, Cy;A S1 Cy;A S0 . In the former case, we
have that


Cmax S1 6 a Nr00 s bW 6 aNr bW ;
while in the latter case, we have that
Cmax S1 6 s bW 6 aN1 bW :
This proves (9). Now, if bW 6 12 Cmax SN ,
then (5) obviously holds. Hence, in the remainder
of this proof we assume that
1
bW > Cmax SN :
2

10

Consider now schedule S2 found in step 5, that

is associated with the collection of sequences
v1 N1 ; v2 N2 ; . . . ; vm Nm . Let z denote the critical
job in schedule S2 .
For schedule S2 ; dene W 0 as the set consisting
of all jobs of set W that are completed on B no
earlier than the critical job z. If W 0 ;, then
Cmax S2 6 Cz;A S2 bN n W
6 aN1 bN n W ;
so that (5) holds due to (3) and (10). Otherwise, let
wp be a job such that


awp min awj j wj 2 W 0 :
Each job in set W 0 starts on B no earlier than
time Cwp ;A S2 awp : Since z is critical in S2 , we
have that awp P Cz;A S2 , so that
Cmax S2 6 awp bW 0 bN n W :

Applying (4) with u wp and U W 0 yields

awp bW 0 6 Cmax SN . Therefore, Cmax S2 6
3
C S  due to (10).
2 max N
This proves the desired bound (5). To see that
3/2 is the best possible ratio for Algorithm RG,
consider the following instance of the F m 1jmj
6 2jCmax problem. Let Z be a suciently large
positive number, e.g., Z  m. The set of jobs N1
contains two jobs 1 and 2 with
a1 Z;

b1 Z m 1;

a2 Z;

b2 0:

The set Nm consists of Z m 4 jobs numbered

by the integers 3m 3, 3m 2,. . . ; Z 2m such
that a3m3 Z; b3m3 1; and
aj bj 1;

j 3m 2; . . . ; Z 2m 1;

aZ2m m 2;

bZ2m 0:

If m > 2, then each set Nk ; 2 6 k 6 m 1; consists of three jobs 3k 3; 3k 2 and 3k 1 such

that
a3k3 Z;

b3k3 1;

a3k1 Z 1;

a3k2 b3k2 1;

b3k1 0:

Notice that zero processing times are understood as very small positive values which can be
neglected.
Algorithm RG may start with schedule S0 associated with the permutations p1 N1 1; 2;
pk Nk 3k 3; 3k 2; 3k 1; k 2; . . . ; m
1; pm Nm 3m 3; 3m 2; . . . ; Z 2m: In S0 ,
for each k; 1 6 k 6 m; a job, which is sequenced to
be rst on machine Ak ; is completed on that machine at time Z. Then machine B is idle till time Z,
and processes the jobs 1; 3; 7; . . . ; 3m 3 in any
order in the time interval Z; 2Z . By time 2Z, every
machine Ak completes the processing of the remaining jobs. These jobs can be processed on B
without idle time, starting at time 2Z. Thus,
Cmax S0 3Z. Moreover, s Z, and w1 1;
wk 3k 3; k 2; . . . ; m.
The structure of schedule S0 implies that Nk0 ;
for each k; 1 6 k 6 m; and therefore, schedule S2
will coincide with S0 . Schedule S1 is associated
with the permutations r1 N1 2; 1; rk Nk
3k 2; 3k 1; 3k 3; k 2; . . . m 1; rm Nm
3m 2; . . . ; Z 2m; 3m 3: In this schedule, for

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

237

each k; 2 6 k 6 m; a job, which is sequenced to be

rst on machine Ak ; is completed on that machine
at time 1. Machine B processes the jobs 4; 7; . . . ;
3m 2 in any order in the time interval 1; m.
Machine Am processes Z m 1 jobs numbered
by 3m 1; 3m; . . . ; Z 2m 1 in the time interval
1; Z m 2. These jobs are processed in the
same order on B in the interval m; Z 1. Job 2 on
machine A1 is completed at time Z. Every machine
Ak ; 2 6 k 6 m 1, in the interval 1; Z processes job
3k 1, while job Z 2m completes on machine Am
at time Z. All these jobs for which the rst-stage
operation is completed at time Z, have a dummy
second-stage operation, supplying no load for
machine B: After time Z every machine Ak processes a job with the processing time Z, so that all
these jobs are completed simultaneously at time
2Z. These jobs can be processed on B without idle
time, starting at time 2Z. Thus, Cmax S1 3Z.
On the other hand, there exists an optimal
schedule SN with Cmax SN 2Z 1. This schedule
is associated, e.g., with the collection of permutations u1 N1 1; 2; uk Nk 3k 2; 3k 3;
3k 1; k 2; . . . ; m 1; um Nm 3m 2; . . . ;
Z 2m 1; 3m 3; Z 2m. The jobs with
dummy second-stage operations are sequenced last
on the corresponding machine. It can be veried
that machine B starts at time 1 and has no idle time.
Thus, we have

We now turn back to the original J m 1

jmj 6 2jCmax problem. Algorithm RG can be easily
modied for nding a heuristic schedule SH for the
ow shop problem of processing the jobs of set H,
for which the rst-stage operations are processed
on the bottleneck machine. Thus, by running Algorithm RG and then its modication, we may nd
two schedules SN and SH : Notice that the makespan
of each of these schedules is at most than 3/2 times
larger than the optimal value for the corresponding
ow shop problem, and, therefore, than the optimal job shop makespan. These schedules can be
then combined as described in Algorithm JS. If in
the resulting schedule the makespan is determined
by the workload of some machine, then the
schedule is optimal due to (2). Otherwise, the
overall makespan is equal to the makespan of one
of the heuristic ow shop schedules SN or SH . This
implies the following statement.

Cmax SN
3Z

;
Cmax SN 2Z 1

In this section we study heuristics that provide

absolute worst-case performance guarantees.
The algorithm given below is an extension of
the heuristic described in [13]. The latter algorithm
is designed for the F m 1jmj 6 2jCmax problem
with m 2. It creates a ow shop schedule in
which the jobs are sorted in non-increasing order
of the ratio bj =aj . We demonstrate that a similar
approach is applicable to a more general situation.

and this ratio approaches 3/2 as Z grows. This

proves the theorem. 
Observe that in fact Algorithm RG takes an
arbitrary schedule as schedule S0 and outputs the
best of three schedules. Intuitively, the performance of the algorithm could be improved if a
specic schedule S0 was chosen as a starting point.
So far we have failed to nd a suitable rule for
choosing S0 , or rather for dening the initial permutations pk Nk ; k 1; 2; . . . ; m. The proof of
the tightness of the bound (5 ) in particular implies
that a ratio of 3/2 will not be reduced if each sequence pk Nk is dened as the Johnson permutation of the jobs of set Nk :

Theorem 2. For the J m 1jmj 6 2jCmax problem,

a schedule S such that
Cmax S=Cmax S  6 3=2
can be found in no more than Onm hm time. The
ratio bound of 3/2 is tight.
6. Heuristic with absolute performance guarantee

Algorithm AG. Input: An instance

J m 1jmj 6 2jCmax problem.
Output: A heuristic schedule SU .
1. For each job j 2 N [ H ; dene

bj =aj if aj > 0;
cj
Z
otherwise;

of

where Z > maxfbj =aj j aj > 0; j 2 N [ H g.

the

238

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

2. For each k; 1 6 k 6 m, nd the sequence uk Nk

by sorting the jobs of set Nk in non-increasing
order of cj . Find the sequence wk Hk by sorting the jobs of set Hk in non-decreasing order
of cj .
3. Run Algorithm JS and call the found schedule
SU . Stop.
The running time of Algorithm AG does not
exceed On log n h log h n hm. The main
advantage of the ordering of the jobs as in step 2 is
that useful relations between the ratios of certain
partial sums can be derived. These relations are
established and explored below.
Lemma 1. Let uk Nk be a sequence found in step 2
of Algorithm AG. Given a job u 2 Nk , define the set
Nk1 of all jobs that precede u in uk Nk : If aNk1 > 0,
then
bNk1
bNk2
P
;
aNk1
aNk2
where

Nk2

Nk n

11

Proof. Without loss of generality, assume that the

jobs in Nk are numbered in such a way that
uk Nk 1; 2; . . . ; r. Therefore, Nk1 f1; 2; . . . ;
u 1g and Nk2 fu; u 1; . . . ; rg. Let s be the rst
job in uk Nk with as > 0: The inequality
aNk1 > 0 implies that s exists and belongs to Nk1 .
It is obvious that
12

It is well known that for any four numbers

c P 0; d > 0; e P 0; f > 0 the inequality c=d P
e=f implies
c
ce
e
P
P :
d
d f
f
Since in uk Nk the jobs s; s 1; . . . ; r are sorted
in non-increasing order of the ratios bj =aj , it follows that

13

On the other hand,

bu
bu bu1
P
P ...
au
au au1
bu bu1 . . . br
:
P
au au1 . . . ar

14

Combining (12)(14), we obtain the desired

inequality (11). This proves the lemma. 
Recall that P  denotes the largest of the machine workloads, while pmax stands for the largest
processing time of an operation. We estimate the
makespan of the found schedule in terms of P  and
pmax .
Theorem 3. For the J m 1jmj 6 2jCmax problem
Algorithm AG generates schedule SU such that
Cmax SU 6 P  pmax :

Nk1 :

Ps
bj
bs
Pj1
P :
s
a
as
j
j1

bs
bs bs1
P
P



as
as as1
bs bs1


bu1
bu1
P
:
P
as as1


au1
au1

15

Proof. Without loss of generality, we assume that

Cmax SU is determined by the length of the ow
shop schedule for processing the jobs of set N.
Similar to the proof of Theorem 1, let the
machines be numbered so that (6) holds.
If for some k; 1 6 k 6 m; the inequality
Cmax SU 6 aNk pmax holds, then the bound (15)
follows immediately. Thus, in the remainder of this
proof we assume that
Cmax SU > aNk pmax ;

k 1; 2; . . . ; m:

16

To prove the theorem we need to show that

Cmax SU 6 bN [ H pmax :

17

Let w be the critical job in SU ; and the processing

of this job on machine B starts at time Rw;B s.
We identify the largest index q such that aNq P s:
Similarly to step 3 of Algorithm RG, for each k,
1 6 k 6 q; we nd the job wk 2 Nk that starts on Ak
before time s and nishes on that machine no
earlier than time s , and dene Nk1 to be the subset
of Nk consisting of the jobs that precede job wk in

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

the permutation uk Nk ; also dene Nk2 Nk n Nk1 .

In schedule SU after time s machine B processes
only the jobs of the sets Nk2 ; k 1; 2; . . . ; q; with no
intermediate idle time, i.e.,
Cmax SU s

q
X
k1

bNk2 :

18

The inequality s 6 pmax leads to the desired

relation (17). Therefore, we assume that
s > pmax :

19

To prove (17), it suces to show that

q
X
k1

bNk1 P s pmax :

20

By denition of job wk ; we have aNk1 awk

P s, which implies that
s pmax 6 aNk1 ;

k 1; 2; . . . ; q:

21

Due to (19), the inequality aNk1 > 0 holds for

each k; 1 6 k 6 q. We now apply Lemma 1 with
u wk to each set Nk Nk1 [ Nk2 ; 1 6 k 6 q, to
obtain
bNk1 P

bNk2 aNk1
:
aNk2

s pmax bNk2
;
aNk s pmax

k 1; 2; . . . ; q:

Summing up and using (16) we get

q
X
k1

bNk1 P s pmax

trivial instance of the job shop problem, in which

H ; and
Nk fkg;

ak bk 1;

k 1; 2; . . . ; m:

Indeed, here P  m, pmax 1 and Cmax S 

m 1.
7. Conclusion
In this paper we have described and analyzed
heuristic algorithms for the two-stage job shop
scheduling problem with a single bottleneck machine. The obtained worst-case analysis results
improve those known for less general scheduling
models.
One of possible directions of future research is
to extend the obtained results to the general twostage job shop. We suspect that the non-approximability result by Williamson et al. [19] does not
hold in this case, so that fast heuristics with a
worst-case ratio of 5/4 or better are likely to exist.
It is also worth studying how the techniques
considered in this paper can be applied to the related problems, such as the ow shop with parallel
machines or the assembly problem.
Acknowledgements

We use aNk2 aNk aNk1 and (21) to derive

bNk1 P

239

q
X
k1

bNk2
aNk s pmax

P
s pmax qk1 bNk2
:
>
Cmax SU s

The required inequality (20) directly follows from

(18). This proves the theorem. 
Notice that the bound (15) cannot be improved
in the following sense: for any a < 1 there exists an
instance of our problem such that Cmax S  >
P  apmax : This can be seen from considering the

This research was partly supported by the International Association for the Promotion of Cooperation with Scientists from the Independent
States of the Former Soviet Union, INTAS93-257-Ext. We are grateful to the anonymous
referees whose comments have contributed to improving the presentation.
References
[1] B. Chen, Analysis of classes of heuristics for scheduling a
two-stage ow shop with parallel machines at one stage,
Journal of the Operational Research Society 46 (1995)
234244.
[2] B. Chen, C.A. Glass, C.N. Potts, V.A. Strusevich, A new
heuristic three-machine ow shop scheduling, Operations
Research 44 (1996) 891898.
[3] I.G. Drobouchevitch, V.A. Strusevich, Heuristics for short
route job shop scheduling problems, Mathematical Methods of Operations Research 48 (1998) 359375.

240

I.G. Drobouchevitch, V.A. Strusevich / European Journal of Operational Research 123 (2000) 229240

[4] M.R. Garey, D.S. Johnson, R. Sethi, The complexity of

ow shop and job shop scheduling, Mathematics of
Operations Research 1 (1976) 117129.
[5] T. Gonzalez, S. Sahni, Flow shop and job shop schedules:
complexity and approximation, Operations Research 26
(1978) 3652.
[6] J.N.D. Gupta, A owshop scheduling problem with two
operations per job, International Journal of Production
Research 35 (1997) 23092325.
[7] L.A. Hall, Approximability of ow shop scheduling,
Mathematical Programming 82 (1998) 175190.
[8] J.W. Herrmann, C.-Y. Lee, Three-machine look-ahead
scheduling problems, Research report No. 92-93, Department of Industrial Engineering, University of Florida,
Gainesville, Florida, USA, 1992.
[9] J.R. Jackson, An extension of Johnson's results on job lot
scheduling, Naval Research Logistics Quarterly 3 (1956)
201203.
[10] S.M. Johnson, Optimal two- and three-machine production schedules with setup times included, Naval Research
Logistics Quarterly 1 (1954) 6168.
[11] E.L. Lawler, J.K. Lenstra, A.H.G. Rinnooy Kan, D.B.
Shmoys, Sequencing and scheduling: Algorithms and
complexity. in: S.C. Graves, A.H.G. Rinnooy Kan, P.H.
Zipkin (Eds.), Handbooks in Operations Research and
Management Science, vol. 4, Logistics of Production and
Inventory, North-Holland, Amsterdam, 1993, pp. 455522.

[12] C.-Y. Lee, G.L. Vairaktarakis, Minimizing makespan in

hybrid owshops, Operations Research Letters 16 (1994)
149158.
[13] Y.D. Neumytov, S.V. Sevast'janov, An approximation
algorithm with an exact bound for the three-machine
problem with the opposite routes, Upravlyaemye Sistemy
31 (1993) 5365 (in Russian).
[14] C. O
guz, B.M.T. Lin, T.C.E. Cheng, Two-stage ow shop
scheduling with a common second-stage machine, Computers and Operations Research 24 (1997) 11691174.
[15] C.N. Potts, S.V. Sevast'janov, V.A. Strusevich, L.N. Van
Wassenhove, C.M. Zwaneveld, The two-stage assembly
scheduling problem: Complexity and approximation,
Operations Research 43 (1995) 346355.
[16] S.V. Sevast'janov, On some geometric methods in scheduling theory, Discrete Applied Mathematics 55 (1994)
5982.
[17] S. Sevast'janov, Vector summation in Banach space and
polynomial algorithms for ow shops and open shops,
Mathematics of Operations Research 20 (1995) 90103.
[18] D.B. Shmoys, C. Stein, J. Wein, Improved approximation
algorithms for shop scheduling problems, SIAM Journal
on Computing 23 (1994) 617632.
[19] D.P. Williamson, L.A. Hall, J.A. Hoogeveen, C.A.J.
Hurkens, J.K. Lenstra, S.V. Sevast'janov, D.B. Shmoys,
Short shop schedules, Operations Research 45 (1997)
288294.