ARTICLE IN PRESS

Int. J. Production Economics 105 (2007) 407424

www.elsevier.com/locate/ijpe

Metaheuristic approaches to the hybrid ow shop scheduling

problem with a cost-related criterion
Adam Janiaka, Erhan Kozanb, Maciej Lichtensteina,, Ceyda Oguzc,1
a

Institute of Engineering Cybernetics, Wroclaw University of Technology, Janiszewskiego 11/17, Wroclaw, Poland
Department of Mathematical Sciences, Queensland University of Technology, GPO Box 2434, Brisbane, Qld. 4001, Australia
c
Department of Logistics, The Hong Kong Polytechnic University, Hung Hom, Kowloon, Hong Kong SAR

Received 2 February 2004; accepted 2 May 2004

Available online 12 October 2005

Abstract
In the paper, the ow-shop scheduling problem with parallel machines at each stage (machine center) is studied. For
each job its release and due date as well as a processing time for its each operation are given. The scheduling criterion
consists of three parts: the total weighted earliness, the total weighted tardiness and the total weighted waiting time. The
criterion takes into account the costs of storing semi-manufactured products in the course of production and ready-made
products as well as penalties for not meeting the deadlines stated in the conditions of the contract with customer. To solve
the problem, three constructive algorithms and three metaheuristics (based one Tabu Search and Simulated Annealing
techniques) are developed and experimentally analyzed. All the proposed algorithms operate on the notion of so-called
operation processing order, i.e. the order of operations on each machine. We show that the problem of schedule
construction on the base of a given operation processing order can be reduced to the linear programming task. We also
propose some approximation algorithm for schedule construction and show the conditions of its optimality.
r 2005 Elsevier B.V. All rights reserved.
Keywords: Scheduling; Flow shop; Tabu search; Simulated annealing

1. Introduction
A variety of production processes can be modeled as a ow-shop scheduling problem. In the classical owshop problem, a set of jobs ow through multiple stages in the same order, where each stage consists of only
one machine. However, being not sufcient for many production processes in technologically developing
manufacturing environments, this classical ow-shop model was extended almost two decades after Johnsons
seminal work (Johnson, 1954) on classical two-stage ow-shop scheduling problem. In this extended model,
each stage consists of a number of identical parallel machines, and can be viewed as a machine center. This
type of ow-shop environment is usually referred to as a hybrid ow-shop or ow-shop with multiple
machines (processors) in the literature (Hoogeveen et al., 1996; Janiak and Lichtenstein, 2001; Lee and
Vairaktarakis, 1994; Riane et al., 1998).
Corresponding author. Tel.: +48 71 3202906; fax: +48 71 3212677.
1

E-mail address: maciej.lichtenstein@pwr.wroc.pl (M. Lichtenstein).

Currently with the Department of Industrial Engineering, Koc- University, Turkey.

0925-5273/$ - see front matter r 2005 Elsevier B.V. All rights reserved.
doi:10.1016/j.ijpe.2004.05.027

ARTICLE IN PRESS
408

A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

Hybrid ow-shop problems have received considerable attention from researchers during the last two
decades. However, the scheduling criterion most frequently considered in those papers was the maximum
completion time, see Chen (1995), Gupta (1988), Haouari and MHallah (1997), Lee and Vairaktarakis (1994)
and Riane et al. (1998). Furthermore, these studies propose either an exact algorithm, which can solve only up
to moderate size problem instances, or different types of heuristic and approximation algorithms (BottaGenoulaz, 2000; Braha and Loob, 1999; Kyparisis and Koulamas, 2001; McMahon and Burton, 1967; Riane
et al., 1998).
In this paper, we also consider a production process, which can be modeled as a hybrid ow-shop problem.
Contrary to the previous studies in the literature, the criterion applied to our problem represents the costs
connected with storing products in the course of production and the penalties for not meeting the deadlines
stated in the contract with the customer.
This study is motivated from an iron foundry factory, located in Queensland, Australia, which produces
over 1500 different products, such as brake drums, train wheels, axle-boxes, etc. After sand-casting, casts are
cleaned and transported to the machine-shop work station for further processing. In the machine-shop work
station, there are 34 machines grouped into centers. There are centers with boring machines, milling machines,
grinding machines, polishing machines, etc., on which parts are processed according to the customers orders.
Between centers parts are transported on palettes of limited capacity (buffers). The main problem in this
factory is that only about 45% of products are completed on time. That bring huge loss to the factory because
of penalties, which have to be paid to the customers. At the same time, the factory does not own enough
storehouses and storing ready-made products causes additional expenses.
Obviously, each of the machine centers can be considered as a stage with a set of identical machines. The
customer orders dene the jobs arriving to the shop oor. Each job ows through the machine centers (stages)
in the same order. At each machine center, a job can be processed on any, but only on one, machine. In the
meantime, each machine can process at most one job at a time. For each job, a release date and a due date are
specied by the customer. The problem is to nd a schedule, which minimizes the cost criterion consists of
three parts: the total weighted earliness, the total weighted tardiness, and the total weighted waiting time. The
earliness part of the criterion represents the costs connected with storing the ready-made products. The
tardiness part represents the penalties, which have to be paid to the customers for not meeting the negotiated
deadlines. Finally, the waiting time part of the criterion represents the costs of storing semi-manufactured
products in the course of production and indirectly minimizes the usage of buffers between centers.
We propose three metaheuristic algorithms based on simulated annealing (SA) and tabu search (TS) to solve
this problem. One of our metaheuristics is a hybrid SA/TS algorithm. To the best of our knowledge, there is a
limited literature on developing metaheuristic algorithms for HFS problems with non-regular criterion (Gupta
et al., 2002; Janiak and Lichtenstein, 2001). The closest problem is considered in the paper (Gupta et al., 2002),
however, the model presented in this paper is differentthe authors consider problem in which jobs are
controllable (processing times depend on additional resource) and also due dates have to be determined during
the optimization process.
The remainder of the paper is organized as follows. In the next section we formulate the problem more
precisely. In Section 3 we present a tool to construct a schedule on the base of so-called operation processing
order, i.e. the order of operations processed on each machine. This tool is needed, since in the constructive
algorithms presented in Section 4 and the metaheuristic algorithms presented in Section 5 we operate on
operation sequences. In Section 3 we also show that the problem of schedule construction can be formulated
as the linear programming task and propose some approximation algorithm for schedule construction. The
results of performed experimental analysis are presented in Section 6. We conclude the paper in Section 7.
2. Problem formulation
The hybrid ow-shop system is dened by the set M f1; . . . ; i; . . . ; mg of m processing stages (machine
centers). At each stage i, i 2 M, there is a set M i f1; . . . ; l; . . . ; mi g of mi identical machines (processors). The
set J f1; . . . ; j; . . . ; ng of n independent jobs has to be processed in the system dened by the sets M and M i .
It is convenient to view each job j; j 2 J, as a sequence of m operations with processing times pij X0, i 2 M.
The ith operation of a job is processed at the ith stage and can commence only after the completion of previous

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

409

operation from the sequence, i.e. operation i  1th. For each job j, j 2 J, the following parameters are given:
rj X0the release date, d j X0the due date, aj X0the cost per time unit of storing job j, bj X0the penalty
per time unit for not meeting the due date of job j, gj X0the cost per time unit of storing the semimanufactured job j in the course of production.
The jobs are processed with respect to the following restrictions: the ith operation of each job is processed
without preemptions on any (but only one) machine of the ith stage; processing of each job cannot be started
before its release date; each machine can process only one operation at a time.
Let Sij X0 and C ij S ij pij denote the starting and the completion time of the ith operation of
job j, respectively. Since at each stage the machines are identical and preemptions are not allowed, to
dene a schedule it is sufcient to specify starting time of each operation. For convenience, by Sj and C j ,
we denote the starting and completion time the last operation of the job j, respectively, i.e. S j S mj
and C j C mj .
The problem is to nd a feasible schedule S^ (i.e. schedule, which satises the restrictions stated above) which
minimizes the following criterion:
^
F S

n
X

aj E j

n
X

j1

bj T j

j1

n
X
j1

gj

m1
X

W ij ,

i1

where





S^ fSij : i 2 M; j 2 Jga schedule, dened by the set of operations starting times,

E j maxf0; d j  C j g maxf0; d j  S j  pmj gthe earliness of the job j,
T j maxf0; C j  d j g maxf0; Sj pmj  d j gthe tardiness of the job j,
W ij S i1;j  C ij S i1;j  Sij  pij the waiting time of the job j between stages i and i 1.

The total waiting time of the job j can be dened as follows:

Wj

m1
X

W ij

i1

m1
X

S i1;j  C ij S j  S1j 

i1

m1
X

pij ,

i1

therefore, the criterion is equal to:

^
F S

n
X

aj E j

n
X

j1

j1

bj T j

n
X

gj W j .

(1)

j1

Since in metaheuristic algorithms it is convenient to operate on job sequences rather than on a schedule, in
the next section we propose a method of constructing the schedule on the base of so-called operation
processing order. At the beginning of the next section we precisely dene the operation processing order and
then propose some algorithm, which constructs a schedule on the base of a given processing order.
3. Schedule construction
In order to present proposed algorithm of schedule construction, rst we introduce the denition of
operations processing order.
Let J il  J and nil jJ il j denote the set and the number of operations processed on machine l of the ith
stage, respectively. Then the sequence of operations on this machine can be dened by a permutation
pil pil 1; pil 2; . . . ; pil k; . . . ; pil nil 2 PJ il , where pil k denotes the operation at the position k in the
permutation pil , and PJ il is the set of all the permutations of the set J il . The operation processing order is
dened by the set of permutations p fpil ; i 2 M; l 2 M i g. The collection of all such processing orders
produces the set
P fp fpil g : pil 2 PJ il ; J il 2 YJ; mi g;

i 2 M; l 2 M i g,

where YJ; mi denotes all the partitions of the set J into mi disjoint subsets.

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

410

To illustrate the problem and notations given above, let us consider the following example:
Example 1. The system has m 3 stages with three machines at the rst stage m1 3, two machines at the
second stage m2 2 and four machines at the third stage m3 4. The set of n 7 jobs with parameters
given in Table 1 has to be processed in this system. The Gantt Chart in Fig. 1 shows a feasible schedule with
criterion value F 300. The processing order of this schedule can be dened by the set of permutations
p fp11 ; p12 ; p13 ; p21 ; p22 ; p31 ; p32 ; p33 ; p34 g. The permutations pij , i 1; 2; 3, j 1; 2; 3; 4, are given as follows:
p11 1; 4, p12 2; 5; 7, p13 3; 6, p21 3; 2; 4; 5; 7, p22 1; 6, p31 3, p32 1, p33 6; 7,
p34 2; 4; 5.
For each xed processing order p 2 P we can construct a schedule S (i.e. determine starting times of
operations) by solving the following linear programming task:
Minimize:
n
X
aj E j bj T j gj W j ,

j1

where
W j S mj  S 1j 

m1
X

pij ,

i1

Table 1
Jobs parameters for the instance in Example 1
rj

dj

aj

bj

gj

p1j

p2j

p3j

1
2
3
4
5
6
7

0
0
0
45
0
40
0

110
70
135
155
165
115
150

4
4
4
4
4
4
4

6
6
6
6
6
6
6

2
2
2
2
2
2
2

35
50
25
20
30
20
25

25
15
25
25
15
20
20

50
25
85
35
40
35
25

machine

Job

r4
r6

1 2

stage

3
1

W51

W52

4
2

5
6

2
2

1
3

d2

5
E4

T2

50

7
4

100
time

Fig. 1. The Gantt Chart for the instance in Example 1.

d4

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

411

E j Xd j  S mj  pmj ;

j 2 J,

T j XS mj pmj  d j ;

j 2 J,

subject to:

Si;pil j XSi;pil j1 pi;pil j1 ,

i 2 M; l 2 M i ; j 2 f2; 3; . . . ; nil g,
Sij XS i1;j pi1;j ;
S1j Xrj ;

i 2 Mnf1g; j 2 J,

j 2 J,

Sij X0;
E j X0;

i 2 M; j 2 J,
j 2 J,

T j X0;

j 2 J.

7
8
9
10

The variables are Sj ; E j ; T j ; j 2 J. The pairs of constraints (3), (9) and (4), (10) assure the proper minimization
of the earliness and the tardiness parts of the criterion (2). The constraint (5) assure that the processing of the
consecutive operation cannot start before the completion of the operation processed previously on the same
machine. The constraint (6) assures that the processing of the ith operation of job j is started after completion of
the operation i  1th of job j. The constraint (7) assures that processing of the job cannot be started before its
release date. Finally, constraints (8)(10) dene all variables as the non-negative values.
Since the efciency of standard methods solving linear programs is rather poor, to solve this particular case
we provide three-stage approximation algorithm (denoted by C).
3.1. Algorithm C
The main idea of the algorithms is as follows: in the rst stage the earliest possible values (for a given
processing order p) of the operations starting times are calculated. Then in the next stage the values of starting
times of operations processed at the last machine center are determined optimally in terms of the earliness and
tardiness parts of the criterion (disregarding waiting time part). Finally, in the third stage Algorithm C
calculates the starting times of operations processed at the machine centers 1; . . . ; mm1 minimizing the waiting
time part of the criterion.
Stage 1 of Algorithm C:
In the rst stage of Algorithm C, having a given operations processing order p, we determine the operations
starting and completion times by using the following recursive formulae calculated for i 1; . . . ; m,
j 2; . . . ; nil and l 1; . . . ; mi ,
Si;pil j maxfSi1;pil j pi1;pil j ; S i;pil j1 pi;pil j1 g,

(11)

where p0j 0 and S 0j rj , j 2 J. The completion times stem from the following expression:
C ij S ij pij .

(12)

The determined values of S ij and C ij are used as an input data for the next stage of the algorithm. One can
notice, that the values of Sij determined in this stage of Algorithm C are the earliest possible, i.e. for a given p
no operation can start earlier than the moment Sij determined in this stage of the algorithm.
Stage 2 of Algorithm C:
In the second stage, we determine the starting and completion times of the operationsPprocessed at
Pthe last
machine center (stage) optimally (see proof of Theorem 1) in terms of the criterion nj1 aj E j nj1 bj T j
(disregarding the waiting time), separately for each machine.
In the description of the algorithm, for convenience, we denote the permutation pml by p.
Also the number
of jobs nml is simply denoted by n . The main idea of this part of the algorithm is based on shifting of the groups
of operations. Let Bj denote the group, i.e. the subset of operations processed consecutively after operation
pj
with no machine idle time, i.e.:
S pk1
;
Bj fpj
1; pj
2; . . . ; pb
j : C pk

k j; . . . ; bj  1g,

(13)

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

412

(Bj)

E(Bj)
(j )

(j+1)

(j+2)

...

(bj)

(bj +1)

d(j+1)

Fig. 2. The illustration to Algorithm C. In the example we assume that job pj

1 has the smallest value of the earliness.

where bj is the position of the last operation in Bj . Let BEj  Bj denote the subset of early jobs in Bj , i.e.
BEj fk 2 Bj : E k 40g. Additionally, let EBj mink2BEj fE k g denote the smallest earliness of early jobs in Bj
and DBj S pb
j 1  C pb
j denotes the machine idle time after the group Bj (see Fig. 2). Assume that if
BEj ; then EBj 1 and also if bj n then DBj 1.
If the following two conditions are satised:
E pj
40
and
apj
4

(14)
zk ,

(15)

k2Bj

where
zk

ak
bk

if E k 40;
otherwise;

(16)

then the group Bj together with job pj

is shifted to the right by the time t minfE pj
; EBj ; DBj g.
After shifting the group, new group Bj is created (if t DBj ) or new values of parameters zk are calculated
(if t EBj ), depending on the value of t. Then new values of the parameters EBj and DBj are calculated
and the shifting process is continued until one of the conditions (14) and (15) is violated. This procedure is
applied to each job from the last position to the rst one, i.e. for j n ; . . . ; 1.
This part of algorithm is applied to each permutation pml , l 2 M m . The pseudo-code and the illustration to
this part of the algorithm are presented in Procedure 1 and Fig. 2, respectively.

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

413

Stage 3 of Algorithm C:
The last stage of Algorithm C is similar to the rst one. In this stage, the starting and completion times of
operations processed at stages m  1; m  2; . . . ; 1 are determined. The following recursive formulae calculated
for i m  1; . . . ; 1; j nil  1; . . . ; 1 and l 1; . . . ; mi , is used:
Si;pil j minfS i1;pil j ; S i;pil j1 g  pi;pil j .
The values of the completion times follow from expression (12). This part of the algorithm minimizes the
waiting time part of the criterion subject to that the starting and completion times of operations processed at
last center are xed.
The pseudo-code of entire algorithm is presented in Procedure 2.

The
and the last stage of the algorithm can be realized in Onm time. The second stage requires
P mrst
2
O m
n

l1 ml steps. Thus, in the worst case (if there is only one machine in the last machine center) the proposed
algorithm requires On2 nm time. However, our experiments show that average time required by Algorithm
C is linearly dependent on the number of jobs, n. This is illustrated in Fig. 3 where we compare the algorithm
running time with the time needed to obtain the optimal solution of linear programming task (2)(10) using
the popular tool CPLEX.
The quality of solutions delivered by this algorithm is strongly dependent on the relation between
parameters aj , bj and gj . The quality of solutions is getting worse with the increase of the gj parameters values,
which is illustrated in Fig. 4, however, the following theorem can be formulated:
Theorem 1. Algorithm C delivers an optimal solution if gj 0 for each j 2 J.
Before we give the proof of Theorem 1 we present some additional denition, property and lemma, which
will be used in the proof.
Property 1. The problem of determining starting and completion times of operations for a given processing order
p can be formulated as the following convex programming task.

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

414

35
30

time [ms]

25
20
15
10
5
0
0

20

40

60

80 100 120 140

number of jobs (n)

160

180

200

Fig. 3. Average running time of Algorithm C (thick line) in comparison to CPLEX (100 instances solved for each number of jobs, only one
machine at last stage).
1.25
1.2

1.15
1.1
1.05
1

0.5

1.5

2.5

3.5

4.5

Fig. 4. Average quality of solutions delivered by Algorithm C, where d maxj2J fgj g=maxj2J faj ; bj g, and Z is the criterion value delivered
by Algorithm C divided by optimal criterion value, for n 10, m 5 (solid line), n 10, m 10 (dashed line), and n 20, m 10 (dotted
line).

Minimize:
n
n
n
X
X
X
aj E j S j
bj T j S j
gj W j S 1j ; S j ,
j1

j1

17

j1

where
E j Sj maxf0; d j  S j  pmj g,

(18)

T j S j maxf0; S j pmj  d j g,

(19)

W j S 1j ; S j S j  S 1j 

m1
X

pij ,

(20)

i1

subject to:
Si;pil j XSi;pil j1 pi;pil j1 ,
i 2 M; l 2 M i ; j 2 f2; 3; . . . ; nil g,
Sij XS i1;j pi1;j ; i 2 Mnf1g; j 2 J,

21
22

S1j Xrj ;

23

Sij X0;

j 2 J,
i 2 M; j 2 J.

24

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

415

The variables are S ij , i 2 M, j 2 J. The constraints (21)(24) have the same meaning as restrictions (5)(8),
respectively.
Proof. It is clear that functions (18)(20) are convex. It is also clear that criterion (17) is a convex function
since it is linear combination of convex functions. The constraints (21)(24) are linear. Finally, the
minimization of a convex function subject to linear constraints is a convex programming task. &
On the basis of Property 1 we can formulate the following lemma.
Lemma 1. In the problem of determining starting and completion times of operations for given processing order p,
any local minimum is also a global one.
Proof. The proof follows from the properties of the convex programming tasks, see e.g. Luenberger
(1969). &
Denition 1. The block of operations on a machine is a sequence with the largest number of operations
processed consecutively with no idle time in between.
Proof of Theorem 1. It is easy to notice that if gj 0 for j 1; . . . ; n the third stage of Algorithm C do not
affect the value of criterion. It is also easy to notice that by applying Procedure 1 to the one of the machines of
the last machine center, we do not affect the value of the criterion implied by the operations performed on the
other machines of this machine center. Thus, it is enough to prove that Procedure 1 is optimal.
The values of starting and completion times of operations determined by the rst stage of Algorithm C
are the earliest possible, i.e. no operation can be started (or completed) earlier than S ij (C ij ) determined in
the rst stage of Algorithm C. Thus, we can say that the values C m1j determined in the rst stage of
Algorithm C are the release dates for the operations processed on the last machine center, and reduce the
entire problem to mm single machine problems with given operations release dates by C m1j . Finally, it is
enough to show that Procedure 1 optimally solves the mentioned above single machine problems. Thus, in
the remaining part of the proof we will focus our considerations on only one of the machines of the last
machine center.
It follows from Lemma 1 that to prove optimality we have to show that local disturbance of the solution
delivered by Procedure 1 do not improve the solution quality.
It is obvious that Procedure 1 can deliver a solution, in which there are several blocks. However, we can
limit our consideration to the solution in which there is only one block, since it is enough to show that slight
change of starting or completion times do not improve the solution, and that change can be so small that will
not affect the other blocks on that machine. Thus, we can assume that there is only one block in the solution,
and (for convenience) that the operations in the block are consecutively numbered form 1 to k. We will show
that modication (increase or decrease) of the starting time of any operation in the solution delivered by
Procedure 1 cannot improve the criterion value, which is enough for optimality.
Let j be any operation in the block. We need to consider two separate cases: (i) increase Sj by d40 time
units and (ii) decrease S j by d40 time units.
Ad. (i):
Now we will show that the increase of the job j starting time, S j , will not cause the decrease of the criterion
value. Assume that we modify the value of S j by d40. It is clear that such modication of S j will cause that
the operations j; . . . ; k will be completed d time units later. After such modication, the criterion value will
change as follows:
dF F 0  F d

k
X

zh ,

hj

where F 0 and F are the values of the criterion after and before modication, respectively, and zh are given by
(16). It is enough to show that dF X0 or equivalently that
k
X
hj1

zh X  zj .

(25)

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

416

that zj aj . After increasing S j , there would be improvement in the criterion value if
PAssume
k
z
oa
j . It is exactly the condition that is checked be Procedure 1, which was not satised during its run.
hj1 h
Thus, the opposite condition was satised, i.e. condition (25).
Now assume that zj bj . Let j 0 4j be the rst operation processed after j, for which zj0 aj 0 .
If such operation does not exist then the operations j; . . . ; k are late and the increase of their starting times
can only increase the criterion value. If such operation j 0 exists then the criterion value can be decreased only if
0

j 1
X

bh

k
X

zh paj0 .

(26)

hj 0 1

hj

It follows from the considerations for the case zj aj , that:

k
X

zh 4aj0 ,

hj 1

Pj0 1
thus the condition (26) cannot be satised since hj
bh X0, which again leads to the conclusion that condition
(25) is satised.
Ad. (ii):
Now we assume that the starting time of the job j is decreased by d40. Such change will cause that
operations 1; . . . ; j will complete d time units earlier. First of all we need to assume that such modication is
possible, i.e. that
S h 4C m1h

for h 1; . . . ; j.

(27)

After the modication, we obtain two separate blocks of operations BL 1; . . . ; j and BR j 1; . . . ; k.

Let us denote the criterion value obtained after the modication of S j by F 0 .
It is easy to notice that after the modication of S j the rst job in the block BL is early (otherwise it would
not be shifted to the right by Algorithm C).
Observe that block BL can be partitioned into some number x of disjoint subblocks
P BL1 ; . . . ; BLx , such that
the rst job BLg 1 in each subblock BLg , g 1; . . . ; x, is early and aBLg 1 4 h2BLg nBLg 1 zh . Otherwise it
would not be shifted to the right by the algorithm.
Now observe that shifting back to the right the last subblock BLx , then the subblock BLx1 and so on up to
BL1 . will cause the decrease of the criterion value. Let us denote this criterion value by F. It is easy to see that
F oF 0 , thus the decrease of the job j starting time cannot improve the criterion value. &
In this section we proposed the algorithm to construct a schedule on the basis of a given operation
processing order. In the next sections we will come back to the main problem, i.e. to the construction of
processing order which minimizes the criterion (1). First of all we propose three constructive algorithms, then
we will focus on metaheuristics.
4. Constructive heuristic algorithms
In this section, we present three two-stage constructive algorithms based on some static priority rules. In the
rst stage of each algorithm we construct some processing order p, then in the second stage, Algorithm C is
applied for constructed p. This algorithms were developed to construct initial solution for metaheuristic
algorithms presented in Section 5.
Each of the proposed constructive algorithms uses the List Scheduling Algorithm (LSA) proposed in
Graham (1966). LSA have been originally proposed for the single-stage problem, however, it can be easily
generalized to the multi-stage problem. The main idea of LSA is to arrange operations in a list and then
assign those to the rst eligible machine. We have considered three rules of arranging jobs (operations) in
the list:
EDD: in each center, arrange operations according to the non-decreasing values d j ,
P
EDP: in each center, arrange operations according to the non-decreasing values d 0j d j  rj  i2M pij ,

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

417

ECT: in the rst center, arrange operations according to the non-decreasing values rj ; in each next center
i f2; . . . ; mg, arrange operations according to the non-decreasing values C i1j , calculated by the rst
stage of Algorithm C.
Each of these rules correspond to one of three constructive heuristic algorithms denoted by EDD, EDP,
ECT, respectively. The pseudo-code of algorithms is presented in Procedure 3. Algorithms EDD and EDP
require Onm n2 time and Algorithm ECT requires Omn log n n2 time.

5. Metaheuristic algorithms
To solve the problem stated, we propose three metaheuristic algorithms based on SA and TS techniques.
One of these algorithms is a hybrid approach based on both mentioned methods. Each of the proposed
algorithms is a neighborhood-based search method, thus we start form the denition of a neigborhood.
The neighborhood of a given (base) solution is dened by moves (transitions) performed from this solution:
Np; V fpv vp; v 2 V pg,
where Np; V denotes the neighborhood of solution p, v denotes a move and V p denotes the set of all
moves, which can be applied to solution p. For the problem under consideration following neighborhood has
been accepted. A move is dened by a vector i; j; a; k; b, i 2 M, a 2 M i , b 2 M i , j 2 f1; . . . ; nia g,
k 2 f1; . . . ; nib g, and represents following change in the solution: operation pia j is removed form permutation
pia and is inserted in permutation pib at position k. The set of moves is dened as follows:
(
V p

i; j; a; k; b; 1pjpnia ; 1pkpnib

if aab;

i; j; a; k; b; 1pjpnia ; 1pkpnib ; kefj  1; jg

if a b;

for i 2 M, a 2 M i , b 2 M i . The restriction kefj  1; jg has been added to avoid redundancy of moves. It is
easy to check that jV pj On2 m. Thus, time required to evaluate entire neighborhood, i.e. to compute the

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

418

criterion value for each solution in the neighborhood, equals:

On4 m n3 m2 .

(28)

5.1. Simulated annealing (SA)

The SA technique, proposed in Kirkpatrick et al. (1983), is an iterative, stochastic, neighborhood-based
search method. The main idea of this technique is to start from some initial solution, p0 , and successively move
among neighboring solutions until the stopping condition is satised. At each iteration, iter, a random
solution, p0 , is selected from the neighborhood of actual solution (piter ) and it replaces it with a probability



F p0  F piter
Ptiter ; piter ; p0 min 1; exp 
,
(29)
titer
where titer is a parameter called the temperature at iteration iter. The temperature decreases during the search
process according to the cooling scheme. The performance of SA depends on the following parameters, which
have to be precisely selected:





initial solution,
neighborhood,
initial temperature and cooling scheme,
stopping condition.

In the following, we present our implementation of SA algorithm. For detailed description of the SA
method we refer the reader to the literature, see e.g. Aarts and Lenstra (1997), Kirkpatrick et al. (1983) and
Tian et al. (1999).
5.1.1. Initial solution
As an initial solution the best among solutions delivered by constructive algorithms ECT, EDD, EDP is
selected.
5.1.2. Initial temperature
The initial temperature is selected on the basis of K nm 1 solutions p0 ; p1 ; . . . ; pK , where pj is randomly
selected from the neighborhood of pj1 and p0 is an initial solution. The initial temperature is dened as
d
,
mn
where d maxj1;...;K fF pj  F pj1 g and parameter W1 0:527 was selected experimentally.
t0 W1

(30)

5.1.3. Cooling scheme

The temperature changes in every iteration according to the logarithmic cooling scheme:
tj
tj1
,
1 ltj
where parameter
tf  t0
l
ft0 tf
and f is the total number of iterations. The nal temperature tf is determined from the following expression:
F p0
,
mn
where parameter W2 0:0108 was selected experimentally.
tf W2

(31)

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

419

5.1.4. Stopping condition

The algorithm stops if the number of iteration iter is greater than MaxIter, an a priori xed constant. In our
experiments we accepted MaxIter 10 000.
5.2. Tabu search (TS)
The TS method, originally proposed by Glover (1986, 1989, 1990), is also iterative, neighborhood-based
search method. However, this method is deterministic. The main idea of this technique is similar to the SA
method, however, at each iteration, a move is performed to the best solution in the neighborhood of actual
one. To avoid cycling and to escape from local minima, the memory of visited solutions is introduced. The
most frequently used type of memory is a short-term memory called the tabu list. In the tabu list some number
of recently visited solutions, their attributes, or moves leading to them are stored. The move is tabu (omitted in
the search process) if it leads to the solution already visited. The efciency and effectiveness of TS algorithm
are dependent on the following parameters:





initial solution,
tabu list,
neighborhood search scheme,
stopping condition.

In the following we present our implementation of TS.

5.2.1. Initial solution
Initial solution is selected in the same way as in SA algorithm, i.e. the best solution among delivered from
ECT, EDD and EDP constructive algorithms.
5.2.2. Tabu list
In our implementation, in the tabu list L, criterion values of Max L recently visited solutions are stored. The
list is initialized with empty elements. Newly added element replaces the oldest one. The move is tabu if it leads
to the solution with criterion value equal to the one of the stored in the tabu list. For our experiments we
accepted the tabu list with xed length Max L maxfn; mg.
5.2.3. Neighborhood search scheme
Since the time required to evaluate the entire neighborhood increases very fast with the increase of the
problem size, see (28), we examine only part of the neighborhood. In our algorithm we evaluate only mn
random neighbors. Thus, single iteration can be realized in On3 m n2 m2 logMax L time.
5.2.4. Stopping condition
The stopping condition is the same as in implementation of SA algorithm. The search process stops if the
number of iterations is greater than MaxIter, an a priori xed constant. In our experiments we accepted
MaxIter 1000.
5.3. Hybrid algorithm (H)
The hybrid algorithm proposed here combines both of the methods previously presented. The main idea of
the algorithm can be described as follows. The search starts from some initial solution p0 and iteratively moves
are performed among neighboring solutions. At an iteration, a random, non-tabu solution p0 is selected from
the neighborhood and it is accepted with the probability given by expression (29). However, if p0 is not
accepted, then neighborhood is searched in the same way as in TS technique. The parameters of selected
solution are stored in the tabu-list. In this method parameters inherited from both methods have to be dened.
In our experiments, these parameters were selected in the same way as in presented SA and TS algorithms. The
only difference is that parameter W1 in expression (30) equals 0.78 and parameter W2 in expression (31) equals

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

420

0.002. In our experiments we accepted MaxIter 1000. The pseudo-code of the algorithm is presented in
Procedure 4.

6. Experimental analysis
All the presented algorithms were implemented in C++ and run on PC 686/400 MHz. To test the quality of
solution obtained from particular algorithms we have generated some problem instances. The instances are
grouped into three categories with respect to the system load:
 T1heavily loaded system,
 T2average loaded system,
 T3lightly loaded system.
For each group and each combination of n and m (n f10; 20; 50; 100; 150g, m f2; 5; 8; 10g) 10 random
instances were generated with parameters uniformly distributed in the following ranges:








operation processing times pij 2 1; . . . ; 100,

release dates rj 2 0; . . . ; 100,
earliness weights aj 2 1; . . . ; 5,
tardiness weights bj 2 3; . . . ; 8,
waiting time weights gj 2 1; . . . ; 3,
the number of machines in each center mi 2 1; . . . ; 5,
due dates d j 50 50kxj =mini2M mi nyj , where xj 2 1; 3, yj 2 8; 30 for instances of category T1,
xj 2 2; 4, yj 2 6; 25 for instances from category T2, and xj 2 3; 5, yj 2 5; 20 for instances from category T3.

Since the problem is NP-hard we could not compare solutions quality with optimal one. Moreover, we
could not construct any reasonable lower bound of the optimal solution. Thus, we veried the algorithms
performance by the following ratios:
 Z A 100%F A  F B =F B the average percentage deviation of the solution of Algorithm A 2 fECT; EDD;
EDP; SA; TS; Hg form the best-found solution F B ,

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

421

Table 2
Results of experimental analysis for constructive algorithms
Category

Z ECT (%)

Z EDD (%)

Z EDP (%)

T1
T2
T3

205.91
217.61
2092.36

59.55
48.87
121.78

65.29
65.92
130.27

Table 3
Comparison of average computation time for metaheuristic algorithms
n

TIMESA

TIMETS

TIMEH

10
20
50
100
150

2
2
2
2
2

1.08
1.44
3.95
5.06
9.02

1.11
4.30
25.73
78.53
198.65

0.77
2.70
17.53
73.74
145.97

10
20
50
100
150

5
5
5
5
5

1.55
2.27
4.13
7.37
11.41

2.69
11.13
68.25
262.25
510.26

1.80
7.08
45.18
183.16
435.77

10
20
50
100
150

8
8
8
8
8

1.78
2.63
5.54
10.09
14.74

4.57
24.19
144.14
554.66
1098.26

2.73
11.61
76.25
275.76
687.12

10
20
50
100
150

10
10
10
10
10

2.07
3.19
6.20
11.00
17.42

7.28
31.82
198.46
715.01
1704.95

3.65
14.37
94.83
350.34
733.99

 TIMEA the average time per iteration in milliseconds for metaheuristic algorithm A 2 fTS; SA; Hg.
The results of experimental analysis are presented in Tables 26.
7. Conclusions
In the paper we proposed some approximation algorithms for the hybrid ow-shop scheduling problem
with the complex, cost-related criterion. The quality of solutions delivered by these algorithms was veried by
the experimental analysis, from which follows the following observations.
The rst observation is that the quality of the constructive solutions is poor. Especially the ECT algorithm is
practically useless, however, in some cases it delivers the best solution among all the constructive algorithms.
We can also observe that the worst performance of constructive algorithms was achieved for instances of
type T3.
The second observation is that all the metaheuristic algorithms signicantly improve the initial solution.
The best improvement is obtained for the algorithm H but it is only slightly better than the results obtained for
TS. The quality of solutions delivered by SA algorithm is rather poor.
The third observation is that the running time of TS and H algorithms strongly increases with the increase
of the problem size. Obviously it is caused by fast increase of the neighborhood size and by the increase of time

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

422

Table 4
The computational results for instances of group T1
n

Z SA (%)

Z TS (%)

Z H (%)

10
20
50
100
150
Average

2
2
2
2
2

8.77
2.58
2.80
5.02
6.72
5.18

0.55
0.56
1.37
3.14
0.00
1.12

0.00
0.00
0.00
0.00
3.47
0.69

10
20
50
100
150
Average

5
5
5
5
5

24.16
10.92
21.72
0.62
1.10
11.70

3.93
5.81
12.29
0.38
0.00
4.48

0.00
0.00
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

8
8
8
8
8

0.00
45.56
18.45
1.13
6.37
14.30

1.03
13.89
2.40
0.00
0.00
3.46

0.00
0.00
0.00
0.13
0.00
0.03

10
20
50
100
150
Average

10
10
10
10
10

0.00
3.60
2.27
6.75
3.81
3.29

1.13
3.57
4.17
1.63
2.71
2.64

1.13
0.00
0.00
0.00
0.00
0.23

8.62

2.93

0.24

Average

Table 5
The computational results for instances of group T2
n

Z SA (%)

Z TS (%)

Z H (%)

10
20
50
100
150
Average

2
2
2
2
2

12.22
9.79
13.17
8.00
19.23
12.48

0.20
1.68
0.77
3.70
1.83
1.64

0.00
0.00
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

5
5
5
5
5

10.74
9.40
8.53
7.99
32.67
13.87

0.17
0.01
4.37
0.00
0.10
0.93

0.00
0.00
0.00
4.07
0.00
0.81

10
20
50
100
150
Average

8
8
8
8
8

18.96
0.06
6.23
0.00
0.02
5.05

0.00
1.27
0.00
1.15
0.00
0.48

0.00
0.01
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

10
10
10
10
10

0.00
3.37
1.34
4.75
3.44
2.58

0.00
1.86
0.32
2.11
1.11
1.08

0.00
0.00
0.00
0.00
0.00
0.00

8.50

1.03

0.20

Average

ARTICLE IN PRESS
A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

423

Table 6
The computational results for instances of group T3
n

Z SA (%)

Z TS (%)

Z H (%)

10
20
50
100
150
Average

2
2
2
2
2

0.00
11.51
8.25
4.56
15.47
7.96

0.00
0.00
0.00
0.00
0.00
0.00

0.00
0.00
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

5
5
5
5
5

0.00
9.84
14.87
9.45
0.08
6.85

0.00
0.00
0.00
0.00
0.00
0.00

0.00
0.00
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

8
8
8
8
8

10.08
9.44
1.88
0.01
0.00
4.28

0.00
0.00
0.00
0.00
0.00
0.00

0.00
0.00
0.00
0.00
0.00
0.00

10
20
50
100
150
Average

10
10
10
10
10

0.00
19.27
1.94
0.33
0.00
4.31

0.00
0.77
0.00
0.00
0.00
0.15

0.00
0.00
0.00
0.00
0.00
0.00

5.85

0.04

0.00

Average

needed to evaluate it. Although, both TS and H surpass the SA in terms of solution quality, the computation
time required by SA is signicantly less. This is caused by the computational complexity of single iteration of
the methods, and allow as to recommend the SA approach for solving the large problem instances. The
proposed hybrid algorithm is the best of the proposed ones. The hybridization of TS with SA speeds up the
algorithm without loosing solution quality.
The presented results shows that modern metaheuristic algorithms are powerful tools for solving real-life,
hard optimization problems.

References
Aarts, E., Lenstra, J.K., 1997. Search in Combinatorial Optimization. Wiley, New York.
Botta-Genoulaz, V., 2000. Hybrid ow shop scheduling with precedence constraints and time lags to minimize maximum lateness.
International Journal of Production Economics 64, 101111.
Braha, S.A., Loob, L.L., 1999. Heuristics for scheduling in a ow shop with multiple processors. European Journal of Operational
Research 113, 113122.
Chen, B., 1995. Analysis of classes of heuristics for scheduling a two-stage ow shop with parallel machines at one stage. Journal of
Operational Research Society 46, 234244.
Glover, F., 1986. Future paths for integer programing and links to articial intelligence. Computers and Operations Research 5, 533549.
Glover, F., 1989. Tabu search. Part I. ORSA Journal on Computing 1, 190206.
Glover, F., 1990. Tabu search. Part II. ORSA Journal on Computing 2, 432.
Graham, R.L., 1966. Bounds for certain multiprocessing anomalies. Bell System Technique Journal 45, 15631581.
Gupta, J.N.D., 1988. Two stage hybrid owshop scheduling problem. Journal of Operational Research Society 39 (4), 359364.
Gupta, J.N.D., Kruger, K., Lauff, V., Werner, F., Sotskov, Y.N., 2002. Heuristics for hybrid ow shops with controllable processing times
and assignable due dates. Computers & Operations Research 29, 14171439.

ARTICLE IN PRESS
424

A. Janiak et al. / Int. J. Production Economics 105 (2007) 407424

Haouari, M., MHallah, R., 1997. Heuristic algorithms for the two-stage hybrid owshop problems. Operations Research Letters 21,
4353.
Hoogeveen, J.A., Lenstra, J.K., Veltman, B., 1996. Preemptive scheduling in a two-stage multiprocessor ow shop is np-hard. European
Journal of Operational Research 89, 172175.
Janiak, A., Lichtenstein, M., 2001. Comparison of some heuristic algorithms for the ow shop problem with parallel machines to minimize
the total earliness, tardiness and waiting time. Operations Research Proceedings 2000, Selected Papers of the Symposium on
Operations Research (OR 2000), Dresden, September 912 2000. Springer, Berlin, pp. 5963.
Johnson, S.M., 1954. Optimal two- and three-stage production schedules with setup times included. Naval Research Logistics Quarterly 1,
6168.
Kirkpatrick, S., Gelatt, C.D., Vecchi, M.P., 1983. Optimisation by simulated annealing. Science 220, 671680.
Kyparisis, G.J., Koulamas, C., 2001. A note on weighted completion time minimization in a exible ow shop. Operations Research
Letters 29, 511.
Lee, C.-Y., Vairaktarakis, G.L., 1994. Minimizing makespan in hybrid owshops. Operations Research Letters 16, 149158.
Luenberger, D.G., 1969. Optimization by Vector Space Methods. Wiley, New York.
McMahon, G.B., Burton, P.G., 1967. Flow-shop scheduling with the branch-and-bound method. Operations Research 15, 473481.
Riane, F., Artiba, A., Elmaghraby, S.E., 1998. A hybrid three-stage owshop problem: efcient heuristics to minimize makespan.
European Journal of Operational Research 109, 321329.
Tian, P., Ma, J., Zhang, D.-M., 1999. Application of the simulated annealing algorithm to the combinatorial optimisation problem with
permutation property: an investigation of generation mechanism. European Journal of Operational Research 118, 8194.