Moth/ Compuf. Modelling, Vol. 13, No. 3, pp.

29-36, 1990

089s7177/90 $3.00 + 0.00

PergamonPress plc

Printedin Great Britain

SCHEDULING
GROUPS OF JOBS IN THE
TWO-MACHINE FLOW SHOP?
K. R. BAKER
The Amos

Tuck

School

of Business

Administration,

Dartmouth

College,

Hanover,

NH 03755, U.S.A.

Abstract-This
paper provides a review of the two-machine
flow shop model when time lags or setups
are introduced.
Building on these results, it establishes a general framework for scheduling groups of jobs
when each group requires a setup.

INTRODUCTION

Scheduling
models for groups of jobs have gained significance
as group technology
(GT) has
become more widely applied. In the GT scheduling problem there is typically an incentive to
perform similar tasks together and a requirement
to incur a setup in order to perform a dissimilar
task. Many basic models for the scheduling of independent
jobs have been extended to the GT
setting. For example, the minimization
of mean flowtime is treated by Yoshida et al. [l], and the
minimization
of mean tardiness is examined by Yoshida et al. [2] and Ozden et al. [3]. Each of these
papers deals with a single-machine
model.
The flow shop model is analyzed by Yoshida and Hitomi [4,5], and their result is reported in
the survey of Ham et al. [6]. However, they consider one variation of many that can occur in the
GT environment.
The purpose of this paper is to develop a general framework within which several
variations
of the GT model can be analyzed for the two-machine
flow shop.
In order to provide the base for this framework, we review the important
results on flow shop
scheduling with time lags. This review states certain key properties that have not been discussed
in the basic papers on this topic. We pay particular attention to the possible overlapping
of tasks.
We also distinguish
anticipatory
(or separable)
setups from nonanticipatory
setups. Although
these two features are not always explicit in scheduling models, they appear at first glance to
generate different problems. However, the general framework we present here permits us to handle
several variants with one basic scheduling rule.
The results we cover pertain to the two-machine
model. Of course, the restriction
to two
machines is limiting, but we know that many interesting
and practical m-machine
problems are
quite difficult to solve. The m-machine
version of the GT scheduling problem considered here is
likely to be even more difficult. However, the optimal solution to two-machine
problems has often
supplied the kernel from which a general solution technique has been developed. Two well-known
examples are the flow shop heuristic of Campbell et al. [7] and the branch-and-bound
procedure
of Lageweg et al. [8]. In the same vein, we expect that the insights gained in solving two-machine
GT problems
will be useful in attacking
larger ones. This same analogy has already been
demonstrated
in the work of Ham et al. [6, Chap. 81.

THE

TWO-MACHINE

FLOW

SHOP

MODEL

In order to describe the basic flow shop model, let uj denote the processing time of job j on
machine 1 and let bj denote the time on machine 2, where precedence requirements
dictate that jobs
must go to machine 1 before machine 2. Indeed, in the basic model, each job must complete all
of its work on machine 1 before it starts on machine 2. The objective is to minimize the schedule
length, or makespan. The fundamental
result for flow shop sequencing [9] states that in this basic
model, job i precedes job i in an optimal sequence if
min(a,, b,) -c min(u,, bi).
tworking paper No. 231 from the Amos Tuck School of Business Administration.
29

(1)

K. R. BAKER

30

(al

(b)

Fig. 1. Right-shifting

to avoid

inserted

idle time.

This ordering allows a complete sequence to be constructed by ranking the job processing times,
starting with the shortest, and breaking ties arbitrarily. The job corresponding to the first
processing time on this list is placed in the first or last available position in sequence, according
to whether the processing time is on machines 1 or 2, respectively. That job is then removed from
consideration, and the remaining list is treated the same way, until all jobs are sequenced.
Normally, when the flow shop model is presented in the literature, diagrams of schedules
produced by Johnsons rule suggest that each operation should be scheduled as early as possible
on each machine. As a result, there is no idle time on machine 1 until all jobs have been processed,
but there may be inserted idle time on machine 2. See Fig. l(a) for such an example. Notice that,
as long as our objective is to minimize makespan, we can also schedule the jobs on machine 2 so
that there is no inserted idle time once processing begins. This simply involves right-shifting the
operations of machine 2 as they appear in Fig. l(a), while maintaining the completion time of the
last operation. Figure l(b) depicts the modification, where i, denotes the idle time on machine 2
before processing begins and i, denotes the idle time on machine 1 after processing is complete.
For convenience, we refer to these respectively as the initial and final idle times of the schedule.
To compute these quantities, let
yk = (al + a2 + ..+ak)-(b,+b,+,..+6,_,).

(2)

The two sums in equation (2) represent the machine workloads that must be completed prior to
the processing of job k at machine 2. Their difference represents the amount of initial idle time
necessary on machine 2 prior to the processing of jobs 1 through k, given that they are processed
without inserting idle time. The quantity yk is a lower bound on i,. Thus,
i, = max( yk).

(3)

+b,)-(ak+,+ak+z+...+a,),

(4)

In symmetric fashion let

x, = (bk + b,+, +..

where n is the number of jobs in the schedule. Then

i2 = max(x,).

(5)

We shall generalize these definitions later on.

THE MODEL WITH TIME LAGS
Time lags (start lags and stop lags) are discussed by Mitten [lo] and several other authors,
leading to the general models presented by Rinnooy Kan [l l] and Szwarc [12]. The motivation for
introducing start and stop lags is to allow for splitting and overlapping of jobs. That is, processing
can begin at machine 2 on an early portion of a job, while the later portion is still at machine 1.
A typical application would be a situation where each job is a batch consisting of several discrete
and identical units. Once the first unit completes at machine 1, it can immediately begin processing
at machine 2. In this case, the start lag represents the time to process one unit on machine 1, and
the stop lag represents the time to process one unit on machine 2. In other words, we would be
using a transfer batch of size 1. Obviously, transfer batches of size > 1 can also be modeled with
the use of time lags. In particular, define a start lag uj as the required delay between the start of
the first operation and the start of the second operation. Analogously, a stop lag Ujis the required
delay between the completion of the first operation and the completion of the second. As shown

The two-machine

flow shop model

(b)

Fig. 2. The relationships

by Rinnooy
specifically,

among

time-lags

and processing

Kan [l 11,the optimal schedule is characterized

job i precedes job j in an optimal sequence if

times.

by a rule analogous

to condition

(1):

min(a, + dii, b, + d,) < min(u, + d,, bi + di),

(6)

where
d, = max(u,-

aj, oj- b,).

(7)

The form of equation (7) in which d, may be negative, reflects the fact that one of the two time
lags will always be binding. If, as in Fig 2(a), we have
d, = uj-a,

> v,-b,,

then the start lag is binding, and a schedule that meets the start-lag constraint
will automatically
satisfy the stop-lag constraint.
On the other hand, if, as in Fig. 2(b), we have
d,= v,-b,>

uj-a/,

then the stop-lag is binding, and a schedule that meets the stop-lag constraint
will automatically
satisfy the start-lag constraint.
In either case, d, represents the time offset between the completion
of the first operation and the start of the second operation.
Conway et al. [13] referred to 4. as
the transfer lag.
Finally, consider the one-job schedule for jobj alone, with a given start-lag and a given stop-lag.
Let e,j denote the idle time on machine 2 prior to processing job j, and let e,, denote the idle time
on machine 1 after processing job j. These quantities are shown in Fig. 3. Then
e,, = aj + d,

(8)

e2,= bj+dj.

(9)

and

Therefore, the rule based on condition

optimal sequence if

(6) can be restated

min(e,,,

ezj) < min(e,j,

as follows: job i precedes

ezi).

As we shall see, this form of the rule proves to be convenient

groups of jobs.
THE

MODEL

WITH

job i in an
(10)

when we analyze

the scheduling

of

SETUPS

In Johnsons original model [9], there is no need to distinguish

setup times and run times;
therefore, setup times are assumed to be contained in processing times. For certain applications,
however, it is useful to treat the setup times as separable; hence we define slj as the setup time for
job j on machine
1 and sSj as the setup time on machine 2. These times are assumed to be
sequence-independent.

Fig. 3. Parameters

for a single job, scheduled

with overlapping

operations.

K. R. BAKER

32

(al

.......
.......

tb)

........
........
........

aj

'lj

Sl.J

............
......
......
......
............

......
......
......

%j

bj

Zj

Fig. 4. A schedule

for one job with setup times that are (a) nonanticipatory

Figure 4(a) shows how a particular job might

features are significant here. First, a job cannot
completed at machine 1 before it can begin work
this means that work must arrive at machine 2 in
the setup cannot be scheduled in anticipation of
two-machine
flow shop problem can be treated
Aj = slj + a,
and then adapt
sequence if

condition

aj

(1) to construct

min(Ai,

bj
and (b) anticipatory.

be scheduled over two machines in this case. Two

be split: this means that the entire job must be
at machine 2. Second, the setup is nonanticipatory:
order for the setup to be initiated. (In other words,
arriving work.) Under these two assumptions
the
in the original manner. Specifically, let

and

E, = sIi i b,

the optimal

sequence:

B,) < min(A,,

(1 I)
job i precedes job j in an optimal

B,).

(12)

The use of capital letters denotes compound

processing times: in this case processing
includes
both setup time and run time.
Consider, for example, what happens if the setup for machine 2 can be scheduled in anticipation
of arriving work, as in Fig. 4(b). We can view this case as a model with
Aj = s,, + aj
and with start-lag

U, = slj + a,-szj and stop-lag

and

B, = szi + b,

V, = by Thus, equations

A,+

max(U,-Aj,

B,-

V,) =~,,+a,-s~~

Ezj= B,+

max(U,-A,,

B,-

V,) = b,

E,j=

(8) and (9) yield:

and

Hence

the general

rule (10) reduces

to the following:

min(s,, + a, - s,, , b,) < min(sli + a/- sz,, b,).

This same result is proven by Yoshida and Hitomi [4,5], working from first principles.
We could also permit overlapping
while recognizing
setups. To address this combination,
must be sure that the start-lag is consistent with the presence of setup times. In other words,
measure the start-lag from the beginning of the setup on machine 1, so that U, > slj if setups
nonanticipatory,
and Uj > slj--s,, if setups are anticipatory.
Thus, there are four cases of
solution, depending
on whether setups are anticipatory
and whether jobs can be overlapped.

SEQUENCING

GROUPS

(13)
we
we
are
the

OF JOBS

In the GT scheduling model, jobs are organized into groups, and the various jobs of a group
must be processed consecutively.
Job k of group j requires a processing time of ajk on machine 1
and bjk on machine 2. In addition, there is a setup time s,~ to initiate the production
of group j
on machine i. The overall scheduling
problem decomposes
into two levels, one involving
the
sequencing of jobs within groups and the other involving the sequencing of the groups themselves.
In the lower-level problem, a sequence must be determined for the jobs in group j. Fortunately,
it is not hard to see that Johnsons rule applies. (The formal proof involves a pairwise interchange
argument, as in the proof for the basic model, showing that no improvement
is possible by violating
the rule.) Note that the time-lag version of Johnsons
rule applies if jobs can be overlapped.
Furthermore,
the setup-time version applies if the jobs within a particular
group each require a

The two-machine

flow shop model

33

minor setup. Assuming that the lower-level problem has been solved, we use the subscript k to mean
the kth job in the optimal sequence for the group.
In the higher-level
problem,
a sequence must be determined
for the groups. The essential
modeling question here is how to redefine groups as pseudo-jobs
in order to apply the existing
results of flow shop theory. Clearly, if setup times are nonanticipatory
and groups must each
complete work on machine 1 before starting on machine 2, then we can simply redefine groups
as jobs and use Johnsons rule. Formally, let

Aj =

Slj +

alk

and

Then

group

i precedes

job j in an optimal

sequence

min(A,,

if

B,) < min(Aj,

B;).

Similarly, if we prohibit the overlapping

of groups but permit anticipatory
setups, then we can
adapt condition
(13) to yield an optimal sequence.
However, the essence of the typical GT scheduling problem is that groups can be processed in
overlapping
fashion, because one of the jobs in the group can occupy machine 2 while another
occupies machine 1. For this reason, our general framework must recognize that groups could
overlap. To allow for overlapping
we invoke the time-lag model, with groups in the role of what
were jobs. Hence, the basic rule governing the sequence of groups is the following: group i precedes
group j in an optimal sequence if
min(A, + Di, B, + 0,) < min(Aj + Dj, Bi + Di),

(14)

where the parameters in this expression refer to properties of groups, being determined
from the
problem data and assumptions
about setups, as we discuss next.
Assume first that setups are nonanticipatory
and that jobs must complete on machine 1 before
starting on machine 2, so that jobs may not be split. Each group will appear in the schedule with
its individual jobs sequenced by Johnsons rule. Also, a setup time will initiate the processing of
the jobs comprising the group, as shown in Fig. 5(a). Without loss of generality, we can reschedule
let Ilj denote the initial
the jobs with no inserted idle time , as shown in Fig. 5(b). For groupj,
group idle time, and let Z2j denote the final time group idle time, as in Fig. 5(b). The reasoning
in equations (2)-(j) leads, similarly, to the following:
I,, = my
where,

(Y,~),

(15)

for k > 1,
_Y,k= (SI, + ajl + aj2 + . . .+a,,)-(S,,+b,,+bj,+...+b,,k_,)

and, for k = 1,
Yjl =

slj +

ql.

Similarly,
12, =

m;x(-u,)~

(a)

(16)

(b)

MCH 1 ::::::
......
......

MCHZ

I,
d..

Fig. 5. Right-shifting

the group

schedule

to avoid

......
........

......
...... .I

inserted

idle time.

K. R. BAKER

34

where, for k > 1,

Xjk=(bjk+bj,k+I++bjg)-(uj.k+,+Uj,k+,++Qjg)

and, for k = 1,
XII= (Szj+ bj, + bj2 + . + bjg)-(~j, + Uj3+ . . +

U,g),

where g is the number of jobs in the group.

With these definitions in place, we can interpret Z,j as the start-lag for group j, and Zzjas the
stop-lag. The parameters are therefore as follows:
Aj = Slj + 1 ajk,
k
Bj

S2j +

bjk9

k
u,

I,j

and

and so
D,=max(U,-Aj,
= max

y--B,)

max(y,k)-slj-~

ajk,

bjk .

maX(Xjk)-s2j-~

Although the optimal sequence can be obtained from condition (14) with the parameters in this
form, it turns out that an alternative version exists, just as condition (10) serves as an alternative
to condition (6) for the sequencing of jobs. With analogous reasoning it can be shown that
Aj+D,=Z,j

and
B, + Dj = Izr.

Therefore

the optimizing rule may be stated as follows: group i precedes group j in an optimal

sequence if
min(I,i, Izj) < min(Z,j, Z2,).

(17)

If setups are anticipatory, this same rule applies, but the yjk and xjk must be calculated
consistently. In equation (15), we have, Vk 2 1,
yjk

(SI,

ajl

uj2 +

.+Ujk)-(S,j+bj,+b,,+...+b,,k_,).

In equation (16) we must take the maximum for k > 0, where, for k > 1,
Xjk=(bjkkbj.k+,++bj~)-(Uj,k+,fUj,k+,+.+Uj~)

and, in addition,
Xjo=(szj+bjl+bjz+..

+ b,k_,) - (Slj + ujl + U,2 f . . + Ujk).

Finally, the result in condition (17) can be extended to overlapping jobs by specifying the
calculation of yjk and xjk appropriately.
EXAMPLE
As a numerical example, consider the three groups described in Table 1. Suppose that setups
are nonanticipatory and that no overlapping of jobs is permitted. The groups in this example each
contain three jobs. Within each group the jobs are already sequenced according to Johnsons rule.

The two-machine

flow shop model

35

Table 1. An example containing three groups and nine jobs, with setup times and
processing times given; for the case of nonanticipatory setups, the I,, values are
computed from the given information
Gr0tlp/
machine
l/l
112
20
212
30
312

Setup
times
5
10
8
IO
5
2

I,, and 12,

values

Process times
5
8
3
6
3
12

II
12
5
5
8
15

8
6
7
3
16
4

10
17
11
12
8
9

Table 2. An example containing three groups and nine jobs, with setup times and
processing times given; for the case of anticipatory setups, the I, values are
computed from the given information
Group/
machine

Setup
times

l/l
112
20
2/2
3/l
312

5
10
8
10
5
2

I,, and rI,

process times
5
8
3
6
3
12

II
12
5
5
8
15

values
8
6
7
3
16
4

3
IO
2
3
6
7

The table summarizes the required calculations with the values of Z,j and I,. These values imply
an optimal group sequence of 3-l-2, as can be verified from the summary of Z-values shown
below:
Group j

Ilj

8
9

10
17

11
12

I 2J

The makespan for the entire schedule is 102.

Now suppose that setups are anticipatory in the same example. Table 2 contains a set of
appropriate calculations, showing the change in the value of I,,. As should be clear from Fig. 5,
the difference between I,j and IIj is unaffected by the change in the assumption about setups.
However, there may still be an incentive to resequence the groups. In this case the optimal
sequences is 2-l-3, as can be verified from the summary of Z-values shown below:
Group j

[lj

2
3

3
10

6
7

I 2,

The makespan for this schedule is 95.

SUMMARY

We have analyzed the two-machine flow shop model involving groups of jobs. Each group
requires a setup on each machine, in order to initiate the processing of the jobs in the group. The
first step in the solution (the lower-level problem) is to order the jobs in each group according to
Johnsons rule. The next step is to calculate the initial group idle time Z,j and the final group idle
time Z,, based on this ordering of jobs. Finally, in the higher-level problem, the groups are
sequenced according to the following rule: group i precedes group i if min(Zli, Ztj) < min(Z,j, Zzi).
This ordering allows a complete sequence to be constructed by ranking the group idle times, starting
with the shortest, and breaking ties arbitrarily. The group corresponding to the first idle time on
this ranked list is placed in the first or last available position in sequence according to whether the
idle time is initial or final, respectively. That group is then removed from consideration, and the
remaining list is treated the same way until all groups are sequenced.

36

K. R. BAKER

The results in this paper generalize Theorem 1 of Kurisu [14], regarding the sequencing of strings
of jobs. Our framework can be viewed as a generalization of the rule in condition (10) for
sequencing overlapping jobs to the sequencing of overlapping groups. As we have seen, the rule
is unchanged if we assume that group setup times are anticipatory instead of nonanticipatory, or
if we assume that individual jobs can be split and overlapped, or if we assume that individual jobs
require minor setups. The only differences occur in the applications of Johnsons rule to the
lower-level problem and in the specific calculation of Zij.
Acknowledgements-The
comments
are gratefully acknowledged.

of Professor

W. Szwarc and an anonymous

referee on earlier drafts of this manuscript

REFERENCES
1. T. Yoshida, N. Nakamura
and K. Hitomi, A study of production
scheduling (optimization
of group scheduling on
a single production
stage). Trans. Japan Sot. mech. Engng 39, 1993-2003 (1973).
2. T. Yoshida, N. Nakamura
and K. Hitomi, Group production
scheduling for minimum total tardiness. AIIE Trans.
10, 157-162 (1978).
3. M. Ozden, P. Egbelu and A. Iyer, Job scheduling in a group technology environment
for a single facility. Computers
ind. Engng 9, 67-72 (1985).
4. T. Yoshida and K. Hitomi, Multi-stage production
scheduling with setup time consideration.
Trans. Japan Sot. mech.
Engng 45 (395) (1979).
5. T. Yoshida and K. Hitomi, Optimal two-stage production
scheduling with setup times separated.
AIIE Trans. 11,
261-263 (1979).
6. I. Ham, K. Hitomi and T. Yoshida, Group Technology. Kluwer-Nijhoff,
Amsterdam
(1985).
7. H. G. Campbell, R. A. Dudek and M. L. Smith, A heuristic algorithm for the n job, m machine sequencing problem.
Mgmt Sci. 16, B630-637 (1970).
8. B. J. Lageweg, J. K. Lenstra and A. H. G. Rinnooy Kan, A general bounding scheme for the permutation
flow shop.
Ops Res. 26, 53-67 (1978).
9. S. M. Johnson, Optimal two- and three-stage production
schedules with setup times included. Nav. Res. Logist. Q. 1,
61-68 (1954).
10. L. G. Mitten, Sequencing n jobs on two machines with arbitrary
time lags. Mgmt Sci. 5, 293-298 (1959).
Il. A. H. G. Rinnooy Kan,M&hine
Scheduling Problems. Stenfert-Kroese,
Amsterdam
(1976).
12. W. Szwarc. Flow shoe problems with time lags. Mnmt Sci. 29, 477-481 (1983).
13. R. W. Conway, W. L. Maxwell and L. W. Miller,-Theory
of .Scheduling: Addison-Wesley,
Reading, Mass. (1967).
14. T. Kurisu, Two-machine
scheduling under required precedence among jobs. J. Ops Res. Sot. Japan 19, l-13 (1976).