A FAST TABU SEARCH ALGORITHM FOR FLOW SHOP
PROBLEM WITH BLOCKING
Jozef Grabowski, Jaroslaw Pempera
Wroclaw University of Technology, Institute of Engineering Cybernetics
Janiszewskiego 11-17, 50-372 Wroclaw, Poland
Keywords:
Flow-shop scheduling; Blocking; Makespan; Local search; Tabu Search.
Abstract:
This paper develops a fast tabu search algorithm to minimize makespan in a flow shop problem with blocking.
We present a fast heuristic algorithm based on tabu search approach. In the algorithm the multimoves are used
that consist in performing several moves simultaneously in a single iteration of algorithm and guide the search
process to more promising areas of the solutions space, where good solutions can be found. It allow us to
accelerate the convergence of the algorithm. Besides, in the algorithm a dynamic tabu list is used that assists
additionally to avoid being trapped at a local optimum. The proposed algorithm is empirically evaluated and
found to be relatively more effective in finding better solutions in a much shorter time.
1 INTRODUCTION
This paper considers the blocking flow shop problem
to minimize makespan. The classical flow shop prob-
lem disregards the behavior of the jobs between two
consecutive operations, i.e. it is assumed that inter-
mediate buffers have infinite capacity and that a job
can be stored for unlimited amount of time.
In a flow shop problem with blocking, there are
no buffers between the machines and a job, having
completed processing on a machine, remains on this
machine and blocks it, until the next machine down-
stream becomes available for processing.
The flow shop problem with blocking has been
studied by many researchers including (Abadi et al.,
2000), (Caraffa et al., 2001), (Grabowski and Pem-
pera, 2000), (Hall and Sriskandarajah, 1996), (Leis-
tein, 1990), (McCormick et al., 1989), (Nowicki,
1999), (Peng et al., 2004), (Reddi and Ramamoor-
thy, 1972), (Ronconi, 2004), (Ronconi and Armen-
tano, 2001), (Smutnicki, 1983).
In this paper, we propose a new heuristic algorithm
based on tabu search technique. The paper is orga-
nized as follows. In Section 2, the problem is defined
and formulated. Section 3 presents the description
of algorithm, moves, neighbourhood structure, search
process and dynamic tabu list. Computational results
are shown in Section 4 and compared with those taken
from the literature.
2 PROBLEM DESCRIPTION AND
PRELIMINARIES
The flow-shop problem with blocking can be formu-
lated as follows.
PROBLEM: Each of n jobs from the set J =
{1, 2, . . . , n} has to be processed on m machines
1, 2, . . . , m in that order, having no intermediate
buffers. Job j ∈ J, consists of a sequence of m
operations O
j1
, O
j2
, . . . , O
jm
; operation O
jk
corre-
sponds to the processing of job j on machine k during
an uninterrupted processing time p
jk
. Since the flow
shop has no intermediate buffers, a job j, having com-
pleted processing of the operation O
jk
, can not leave
the machine k, until the next machine k + 1 is free,
k = 1, 2, . . . , m−1, j ∈ J. If the machine k+1 is not
free, then job j is blocked on the machine k. We want
to find a schedule such that the processing order of
jobs is the same on each machine and the maximum
completion time is minimal.
Each schedule of jobs can be represented by per-
mutation π = (π(1), . . . , π(n)) on set J. Let Π de-
note the set of all such permutations. We wish to find
such permutation π
∗
∈ Π, that
C
max
(π
∗
) = min
π ∈Π
C
max
(π),
where C
max
(π) is the time required to complete all
jobs on the machines in the processing order given
71
Grabowski J. and Pempera J. (2005).
A FAST TABU SEARCH ALGORITHM FOR FLOW SHOP PROBLEM WITH BLOCKING.
In Proceedings of the Second International Conference on Informatics in Control, Automation and Robotics, pages 71-76
DOI: 10.5220/0001160900710076
Copyright
c
 SciTePress

by π. It is known from literature (Ronconi, 2004)
that C
max
(π) = D
π ( n)m
, where the departure time
D
π ( j)k
of job π(j) on machine k can be found using
the following recursive expressions:
D
π (1)0
= 0, k = 1, . . . , m − 1,
D
π (1) k
=
P
k
l=1
p
π (1) l
, k = 1, . . . , m − 1,
D
π ( j)0
= D
π ( j−1), 1
, j = 2, . . . , n,
D
π ( j)k
= max{D
π ( j)k−1
+ p
π ( j)k
, D
π ( j−1), k+1
},
j = 2, . . . , n, k = 1, . . . , m − 1,
D
π ( j)m
= D
π ( j),m −1
+ p
π ( j)m
, j = 1, . . . , n.
The two-machine flow shop problem with block-
ing can be solved in O(nlogn) time (Reddi and Ra-
mamoorthy, 1972) using an improved implementation
by (Gilmore et al., 1985) of the algorithm of (Gilmore
and Gomory, 1964). For m > 2, the problem is un-
fortunately NP-hard.
It is useful to present the considered problem by
using a graph (Grabowski and Pempera, 2000). For
the given processing order π, we create the graph
G(π) = (N, R ∪ F
0
(π) ∪ F
−
(π)) with a set of nodes
N and a set of arcs R ∪ F
0
(π) ∪ F
−
(π), where:
• N = {1, ..., n}×{1, ..., m}, where node (j, k) rep-
resents the k-th operation of job π(j). The weight
of node (j, k) ∈ N is given by the processing time
p
π ( j)k
.
• R =
n
S
j=1
m−1
S
k=1
{((j, k), (j, k + 1))}. Thus, R con-
tains arcs connecting consecutive operations of the
same job.
• F
0
(π) =
n−1
S
j=1
m
S
k=1
{((π(j), k), (π(j+1), k))}. Arcs
from F
0
(π) connect jobs to be processed on the
machines in the processing order given by π. Each
arc of F
0
(π) has weight zero.
• F
−
(π) =
n−1
S
j=1
m−1
S
k=1
{((π(j), k + 1), (π(j + 1), k)}.
Each arc ((π(j), k+1), (π(j+1), k)) ∈ F
−
(π) has
weight minus p
π ( j),k+1
and ensures the blocking
of job π(j + 1) (i.e. operation O
π ( j+1) ,k
) on the
machine k, if the machine k + 1 is not free.
The makespan C
max
(π) of the flow-shop problem
with blocking is equal to the length of the longest
(critical) path from node (1, 1) to (n, m) in G(π).
Each path from (1, 1) to (n, m) can be repre-
sented by a sequence of nodes, and let denote a crit-
ical path in G(π) by u = (u
1
, u
2
, . . . , u
w
), where
u
i
= (j
i
, k
i
) ∈ N, 1 ≤ i ≤ w and w is the num-
ber of nodes in this path. Obviously, it has to be
u
1
= (j
1
, k
1
) = (1, 1), and u
w
= (j
w
, k
w
) = (n, m).
The critical path can naturally be decomposed into
several specific subpaths and each of them contains
the nodes linked by the same type of arcs, i.e. all arcs
of the subpath belong either to F
0
(π) or to F
−
(π).
The first type of subpaths is determined by a maxi-
mal sequence (u
g
, ..., u
h
) = ((j
g
, k
g
), . . . , (j
h
, k
h
)))
of u such that k
g
= k
g + 1
= . . . = k
h
and
((j
i
, k
i
), (j
i+1
, k
i+1
)) ∈ F
0
(π) for all i = g, . . . , h−
1, g < h. Each such subpath determines the sequence
of jobs
B
g h
= (j
g
, j
g + 1
, . . . , j
h−1
, j
h
),
which is called the block of jobs in π. Jobs j
g
and
j
h
in B
g h
are the first and last ones, respectively. A
block corresponds to a sequence of jobs (operations)
processed on machine k
g
without inserted idle time.
Next, we define the internal block of B
g h
as the
subsequence
B
∗
g h
= B
g h
− {j
g
, j
h
}.
The second type of subpaths is defined by a max-
imal sequence (u
s
, ..., u
t
) = ((j
s
, k
s
), . . . , (j
t
, k
t
)))
of u such that ((j
i
, k
i
), (j
i+1
, k
i+1
)) ∈ F
−
(π) for all
i = s, . . . , t−1, s < t. Each such subpath determines
the sequence of jobs
A
st
= (j
s
, j
s+1
, . . . , j
t−1
, j
t
),
which is called the antiblock of jobs in π. Similarly
to in B
g h
, jobs j
s
and j
t
in A
st
are the first and
last ones, respectively. An antiblock corresponds to
blocked jobs. Note that operation O
π ( j
i
)k
i
of jobj
π ( j
i)
is processed on machine k
i
with k
i
> k
i+1
= k
i
− 1,
i = s, . . . , t − 1. Similarly to in B
g h
, now we define
the internal antiblock of A
st
as the subsequence
A
∗
st
= A
st
− {j
s
, j
t
}.
The critical path u can contain many different blocks
and antiblocks, and let l
B
and l
A
denote, respectively,
the numbers of blocks and antiblocks in u . Each of
blocks (or antiblocks) can be characterized by the pair
(g
i
, h
i
), i = 1, . . . , l
B
(or (s
i
, t
i
), i = 1, . . . , l
A
), and
let GH = {(g
i
, h
i
) | i = 1, . . . , l
B
} (or ST =
{(s
i
, t
i
) | i = 1, . . . , l
A
}) be the set of the pairs de-
noting all blocks (or antiblocks) in u.
Property 1 (Grabowski and Pempera, 2000).
For any block B
g h
(or antiblock A
st
) in π, let α be
a processing order obtained from π by an interchange
of jobs from the internal block B
∗
g h
(or A
∗
st
). Then we
have C
max
(α) ≥ C
max
(π).
Immediately from Property 1, it results the follow-
ing Theorem
Theorem 1 .
Let π ∈ Π be any permutation with blocks B
g h
and antiblocks A
st
. If the permutation β has been
obtained from π by an interchange of jobs that
C
max
(β) < C
max
(π), then in β
ICINCO 2005 - INTELLIGENT CONTROL SYSTEMS AND OPTIMIZATION
72

(i) at least one job j ∈ B
g h
(or j ∈ A
st
) precedes job
j
g
(or j
s
), for some (g, h) ∈ GH (or (s, t) ∈ ST ),
or
(ii) at least one job j ∈ B
g h
(or j ∈ A
st
) succeeds job
j
h
(or j
t
) , for some (g, h) ∈ GH (or (s, t) ∈ ST ).
Note that Theorem 1 provides the necessary con-
dition to obtain a permutation β from π such that
C
max
(β) < C
max
(π).
3 ALGORITHM TABU SEARCH
WITH MULTIMOVE (TS+M)
Currently, tabu search (TS) approach, see (Glover,
1989) and (Glover, 1990), is one of the most effective
methods using local search techniques to find near-
optimal solutions of many combinatorial intractable
optimization problems, such as the vast majority of
scheduling problems. This technique aims to guide
the search by exploring the solution space of a prob-
lem beyond local optimality. Since TS has not been
applied to our problem, we propose a TS approach.
The main idea of this method involves starting from
an initial basic job permutation and searching through
its neighbourhood, a set of permutations generated
by the moves, for a permutation with the lowest
makespan. The search then is repeated starting from
the best permutation, as a new basic permutation, and
the process is continued. One of the main ideas of
TS is the use of a tabu list to avoid cycling, overcom-
ing local optimum, and to guide the search process
to the solutions regions which have not been exam-
ined. The tabu list records the performed moves that,
for a chosen span of time, have tabu status and cannot
be applied currently (they are forbidden); that is they
determine forbidden permutations in the currently an-
alyzed neighbourhood. Usually, the algorithm TS ter-
minates when it has performed a given number of iter-
ations (Maxiter), time has run out, the neighbourhood
is empty, a permutation with a satisfying makespan
has been found, etc.
3.1 Moves and neighbourhood
One of the main components of a local search algo-
rithm is the definition of the move set that creates a
neighbourhood. A move changes the location of some
jobs in a given permutation. The intuition following
from Theorem 1 suggests that the ”insert” type move
should be the most proper one for the problem con-
sidered. Let v = (π(x), π(y)) be a pair of jobs in a
permutation π, x, y ∈ {1, 2, ..., n}, x 6= y. The pair
v = (π(x), π(y)) defines a move in π. This move
consists in removing job π(x) from its original posi-
tion x, and next inserting it in the position immedi-
ately after job π(y) (or before π(y)) in π if x < y (or
x > y).
The neighbourhood of π consists of permutations
π
v
obtained by moves from a given set M , and de-
noted as N (M, π) = {π
v
| v ∈ M }. The proper
selection of M is very important to construct an ef-
fective algorithm.
For each job j we consider at most one move to the
right and at most one to the left. Moves are associ-
ated with blocks and antibloks. Let us take the block
B
g h
= (j
g
, j
g + 1
, . . . , j
h−1
, j
h
)) in π. Now we define
the sets of candidates
E
a
g h
= {j
g
, j
g + 1
, . . . , j
h−1
} = B
g h
− {j
h
},
E
b
g h
= {j
g + 1
, . . . , j
h−1
, J
h
)} = B
g h
− {j
g
}.
Each set E
a
g h
(or E
b
g h
) contains the jobs in block B
g h
of π that are candidates for being moved to a position
after (or before) all other jobs in this block.
For any block B
g h
in π, we define the following set
of moves to the right
RB
g h
= {(j, j
h
) | j ∈ E
a
g h
},
and the set to the left
LB
g h
= {(j, j
g
) | j ∈ E
b
g h
}.
Set RB
g h
contains all moves of jobs of E
a
g h
to the
right after the last job j
h
of block B
g h
. By anal-
ogy, set LB
g h
contains all moves of jobs of E
b
g h
to the left before the first job j
g
of block B
g h
. It
should be found that for each move v ∈ RB
g h
(or
v ∈ LB
g h
) , the necessary condition of Theorem 1 is
satisfied to obtain a permutation π
v
from π such that
C
max
(π
v
) < C
max
(π). As a consequence, in algo-
rithm, we will employ the set of moves
MB =
[
(g , h)∈ GH
[RB
g h
∪ LB
g h
],
The similar considerations can be provided for the
antiblocks A
st
, and we then obtain the set of moves
MA =
[
(s,t)∈ST
[RA
st
∪ LA
st
].
Finally, in our TS+M, we propose the following set of
moves
M = MB ∪ M A,
which creates neighbourhood N (M, π).
In order to accelerate the convergence of the algo-
rithms to good solutions, we propose to use the mul-
timoves. A multimove consists of several moves that
are performed simultaneously in a single iteration of
algorithm. The performances of the multimoves al-
low us to generate permutations that differ in various
significant ways from those obtained by performing a
single move and to carry the search process to hitherto
A FAST TABU SEARCH ALGORITHM FOR FLOW SHOP PROBLEM WITH BLOCKING
73

non-visited regions of the solution space. Further-
more, in our algorithm, the multimoves have the pur-
pose of guiding the search to visit the more promising
areas, where ”good solutions” can be found. In lo-
cal search algorithms, the use of multimoves can be
viewed as a way to apply a mixture of intensification
and diversification strategies in the search process.
In the following we present a method that will be
used in our TS algorithm to provide the multimoves.
For the blocks B
g h
, we consider the following sets
of moves
RB
∗
g h
= {(j, j
h
) | j ∈ B
∗
g h
},
LB
∗
g h
= {(j, j
g
) | j ∈ B
∗
g h
}.
Set RB
∗
g h
(or LB
∗
g h
) contains all moves that insert the
jobs from the internal block B
∗
g h
after the last job j
h
(or before the first job j
g
) of this block (see Section
Moves and neighbourhood).
Next, for the block B
g h
, the ”best” move v
R(gh)
∈
RB
∗
g h
and v
L(g h)
∈ LB
∗
g h
are chosen (respectively):
C
max
(π
v
R(gh)
) = min
v ∈ RB
∗
gh
C
max
(π
v
),
C
max
(π
v
L(gh)
) = min
v ∈ LB
∗
gh
, v6=v
R(gh)
C
max
(π
v
),
and the following sets of moves are created
RB = {v
R(gh)
| (g, h) ∈ GH},
LB = {v
L(g h)
| (g, h) ∈ GH},
and
BB = RB ∪ LB = {v
1
, v
2
, ..., v
2l
B
}.
Let
BB
(−)
= {v ∈ BB | C
max
(π
v
) < C
max
(π)} =
= {v
1
, v
2
, ..., v
p
}, p ≤ 2l
B
.
be the set of the profitable moves of blocks B
g h
per-
forming of which generates permutation π
v
”better”
than π.
The similar consideration can be provided for the
antiblocks A
st
, and we then obtain their the set of
profitable moves
BA
(−)
= {v ∈ BA | C
max
(π
v
) < C
max
(π)} =
= {v
1
, v
2
, ..., v
q
}, q ≤ 2l
A
.
The main idea of a multimove is to consider a search
which allows us several moves to be made in a sin-
gle iteration and carry the search to the more promis-
ing areas of solution space, where ”good solutions”
can be found. In our algorithm, the set of promising
moves can be defined as follows
BM
(−)
= BB
(−)
∪ BA
(−)
= {v
1
, v
2
, ..., v
z
},
z ≤ 2(l
B
+ l
A
).
From the definition of BM
(−)
it results that each
move v ∈ BM
(−)
produces permutation π
v
”bet-
ter” than π. Therefore, as a multimove, we took the
set BM
(−)
. The use of this multimove consists in
performing all the moves from BM
(−)
simultane-
ously, generating a permutation, denoted as π
v
, where
v = BM
(−)
. To simplify, in the further consider-
ations, multimove BM
(−)
will be denoted alterna-
tively by
v.
3.2 Search process
TS+M starts from an initial basic permutation π that
implies the neighbourhood N(M, π). This neigh-
bourhood is searched in the following manner.
First, the ”best” move v
∗
∈ M that gener-
ates the permutation π
v
∗
∈ N (M, π) with the
lowest makespan is chosen, i.e. C
max
(π
v
∗
) =
min
v ∈ M
C
max
(π
v
). If C
max
(π
v
∗
) < C
∗
(where C
∗
is the best makespan found so far), then the move v
∗
is selected for the search process. Otherwise, i.e. if
C
max
(π
v
∗
) ≥ C
∗
, then the set of unforbidden moves
(UF) that do not have the tabu status, is defined
UM = {v ∈ M | move v is UF}.
Next, the ”best” move v
∗
∈ UM that generates
the permutation π
v
∗
∈ N(U M, π) with the lowest
makespan, i.e. C
max
(π
v
∗
) = min
v ∈ U M
C
max
(π
v
),
is chosen for the search.
If the move v
∗
is selected, then a pair of jobs cor-
responding to the move v
∗
is added to the tabu list
(see next section Tabu list and tabu status of move for
details) and the resulting permutation π
v
∗
is created.
Next, this permutation becomes the new basic one,
i.e. π := π
v
∗
and algorithm restarts to next iteration.
We develop our algorithm tabu search by using
the multimoves in some specific situations.If permu-
tation π
v
is obtained by performing a multimove
v,
then the next one is made when Piter of the con-
secutive non-improving iterations will pass in TS+M.
In other words, the multimove is used periodically,
where Piter is the number of the iterations between
the neighbouring ones.
If a multimove is performed, then a pair of jobs
corresponding to the move v
∗
∈
v with the smallest
value of C
max
(π
v
∗
) is added to tabu list T . The Piter
is a tuning parameter which is to be chosen experi-
mentally.
3.3 Tabu list and tabu status of move
In our algorithm we use the cyclic tabu list defined
as a finite list (set) T with length LengthT contain-
ing ordered pairs of jobs. The list T is a realiza-
tion of the short-term search memory. If a multi-
move
v is performed on permutation π, then, for the
ICINCO 2005 - INTELLIGENT CONTROL SYSTEMS AND OPTIMIZATION
74

”best” move v
∗
= (π(x), π(y)) ∈ v, the pair of jobs
(π(x), π(x+1)) if x < y, or the pair (π(x−1), π(x)))
if x > y, representing a precedence constraint, is
added to T . Each time before adding a new ele-
ment to T , we must remove the oldest one. With re-
spect to a permutation π, a move (π(x), π(y)) ∈ M
is forbidden, i.e. it has tabu status, if A(π(x)) ∩
{π(x + 1), π(x + 2), ..., π(y)} 6= ∅ if x < y, and
B(π(x)) ∩ {π(y), π(y + 1), ..., π(x − 1)} 6= ∅ other-
wise, where
A(j) = {i ∈ J | (j, i) ∈ T },
B(j) = {i ∈ J | (i, j) ∈ T }.
Set A(j) (or set B(j)) indicates which jobs are to be
processed after (or before) job j with respect to the
current content of the tabu list T.
As mentioned above, our algorithm uses a tabu list
with dynamic length. This length is changed cycli-
cally, as the current iteration number iter of TS+M
increases, using the “pick“ in order to avoid be-
ing trapped at a local optimum (see (Grabowski and
Wodecki, 2004) for details). This kind of tabu list can
be viewed as a specific disturbance and was employed
on that very fast tabu search algorithm proposed by
Grabowski and Wodecki (Grabowski and Wodecki,
2004), where it was successfully applied to the classi-
cal flow shop problem.
4 COMPUTATIONAL RESULTS
In this section we report the results of empirical tests
to evaluate the relative effectiveness of the proposed
tabu search algorithm. So far the best heuristic al-
gorithms for a permutation flow-shop problem with
blocking were presented in papers by (Abadi et al.,
2000), (Caraffa et al., 2001), (Leistein, 1990), (Mc-
Cormick et al., 1989), (Nowicki, 1999), (Ronconi,
2004). It is showed that the best heuristic algorithm
is that proposed by Nowicki (Nowicki, 1999), de-
noted here as TSN. Therefore, we compare our al-
gorithm TS+M with TSN which is also based on the
tabu search approach.
Both algorithms TS+M and TSN were coded in
C++, run on a PC with Pentium IV 1000MHz proces-
sor and tested on the benchmark instances provided
by (Taillard, 1993) for the classic permutation flow
shop, by considering all machines as the blocking
constraints are required. The benchmark set contains
120 particularly hard instances of 12 different sizes,
selected from a large number of randomly generated
problems. For each size (group) n × m: 20 × 5,
20 × 10, 20 × 20, 50 × 5, 50 × 10, 50 × 20, 100 × 5,
100 × 10, 100 × 20, 200 × 10, 200 × 20, 500 × 20, a
sample of 10 instances was provided.
The algorithms based on the tabu search method,
needs an initial permutation, which can found by any
Table 1: Computational results
TSN TS+M
M axiter 30000 1000 3000 30000
n × m APRI ACPU APRI ACPU APRI ACPU APRI ACPU
20 × 5 2.93 2.4 2.87 0.1 3.08 0.3 4.08 2.5
20 × 10 4.51 4.1 3.27 0.1 4.11 0.4 4.75 4.4
20 × 20 2.83 7.2 2.33 0.3 2.39 0.7 2.89 7.3
50 × 5 1.69 6.0 2.04 0.2 2.34 0.6 3.05 6.1
50 × 10 3.13 10.8 2.63 0.4 3.18 1.0 4.04 10.9
50 × 20 3.70 19.1 2.01 0.7 2.47 1.9 4.42 20.1
100 × 5 0.79 12.3 0.98 0.4 1.18 1.3 1.78 12.8
100 × 10 1.98 21.9 1.78 0.7 2.06 1.8 3.00 23.1
100 × 20 2.56 39.5 1.76 1.3 2.12 2.2 3.04 40.9
200 × 10 0.73 44.1 1.03 1.5 1.28 4.0 1.93 46.3
200 × 20 1.35 79.4 1.30 2.7 1.68 8.0 2.52 82.1
500 × 20 0.36 213 0.49 7.0 0.60 20.0 1.12 205
all 2.21 1.87 2.21 3.05
method. In our tests, we use algorithm NEH (Nawaz
et al., 1983) in its original version, which is consid-
ered to be the best one (champion) among simple
constructive heuristics for flow-shop scheduling. In
our tests, for each instance, TS+M algorithm is ter-
minated after performing Maxiter = 1 000, 3 000 and
30 000 iterations, whereas TNS performed Maxiter =
30 000 iterations. The value of tuning parameter Piter
is drawn from (Grabowski and Wodecki, 2004) equal
to 3. The effectiveness of our algorithms was ana-
lyzed in both terms of CPU time and solution quality.
For each test instance, we collected the following
values:
• P RI = 100%(C
NEH
− C
A
)/C
NEH
– the
value of the percentage relative improvements of
the makespan C
A
obtained by algorithm A =
{T SN, T S + M} with respect to the makespan
C
NEH
obtained by algorithm NEH.
• CP U – the computer time (in seconds).
Then, for each size (group) n × m, the following
measures of the heuristic quality were calculated
• AP RI – the average (for 10 instances) percentage
relative improvements of the makespans.
• ACP U – the average (for 10 instances) computer
time.
The computational results presented in Table 1
show that, in terms of APRI values, our algorithm
TS+M, for M axiter =30 000 iterations, performs
significantly better than TSN in comparable the CPU
times. The TS+M found makespans with the overall
average APRI equal to 3.05, whereas TSN found the
ones with 2.21. The superiority of TS+M over TSN
increases with the size of instances. And so, for the
largest instances with n × m = 500 × 20, the TS+M
found makespans with average APRI equal to 1.12,
A FAST TABU SEARCH ALGORITHM FOR FLOW SHOP PROBLEM WITH BLOCKING
75

whereas TSN found the ones with APRI = 0.36. For
the instances with n × m = 200 × 20, respective val-
ues are equal to 2.52 and 1.35.
Analysing the performance of our algorithm, we
have observed that TS+M converges to the good so-
lutions significantly faster, on the average, than TSN.
The APRI values for all instances equal to 2.21 was
found by TSN in 30 000 iterations whereas for TS+M
the respective number is 3 000 iterations. Further-
more, about 85 % improvements obtained by TS+M
(i.e. APRI = 1,87 - for all instances) has been reached
in 1 000 iterations.
Generally speaking TS+M produces better results
than TSN in a significantly shorter time.
ACKNOWLEDGEMENTS
This research has been supported by KBN Grant 4
T11A 016 24. The authors are due to anonymous ref-
erees for their useful comments and suggestions.
REFERENCES
Abadi, I. N. K., Hall, N., and Sriskandarayah, C. (2000).
Minimizing cycle time in a blocking flowshop. Oper-
ations Research, 48:177–180.
Caraffa, V., Ianes, S., Bagchi, T., and Sriskandarayah, C.
(2001). Minimizing makespan in a blocking flow-
shop using genetic algorithms. International Journal
of Production Economics, 70:101–115.
Gilmore, P. and Gomory, R. (1964). Sequencing a state-
variable machine: a solvable case of the traveling
salesman problem. Operations Research, 12:655–
679.
Gilmore, P., Lawler, E., and Shmoys, D. (1985). Well-
solved special cases. E.L. Lawler, J.K. Lenstra,
A.H.G. Rinnooy Kan, D.B. Shmoys (Eds), The Trav-
eling Salesman Problem: A Guided Tour of Combina-
torial Optimization. Wiley: Chichester, pages 87–143.
Glover, F. (1989). Tabu search. part i. ORSA Journal of
Computing, 1:190–206.
Glover, F. (1990). Tabu search. part ii. ORSA Journal of
Computing, 2:4–32.
Grabowski, J. and Pempera, J. (2000). Sequencing of jobs
in some production system. European Journal of Op-
erational Research, 125:535–550.
Grabowski, J. and Wodecki, M. (2004). A very fast
tabu search algorithm for the flow shop problem with
makespan criterion. Computers and Operations Re-
search, 11:1891–1909.
Hall, N. and Sriskandarajah, C. (1996). A survey of ma-
chine scheduling problems with blocking and no-wait
in process. Operations Research, 44:510–525.
Leistein, R. (1990). Flowshop sequencing with limited
buffer storage. International Journal of Production
Research, 28:2085–2100.
McCormick, M., Pinedo, M., Shenker, S., and Wolf, B.
(1989). Sequencing in an assembly line with block-
ing to minimize cycle time. Operations Research,
37:925–935.
Nawaz, M., Enscore, E., and Ham, I. (1983). A heuristic al-
gorithm for the m-machine, n-job flowshop sequenc-
ing problem. OMEGA The International Journal of
Management Science, 11:91–95.
Nowicki, E. (1999). The permutation flow shop with
buffers: A tabu search approach. European Journal
of Operational Research, 116:205–219.
Peng, Y., Soong, B., and Wang, L. (2004). Electronics Let-
ters, 40:375–376.
Reddi, S. and Ramamoorthy, C. (1972). On flowshop se-
quencing problems with no-wait in process. Opera-
tional Research Quarterly, 23:323–331.
Ronconi, D. (2004). A note on constructive heuristics for
the flowshop problem with blocking. International
Journal of Production Economics, 87:39–48.
Ronconi, D. and Armentano, V. (2001). Lower
bounding schemes for flowshops with blocking in-
process. Journal of the Operational Research Society,
52:1289–1297.
Smutnicki, C. (1983). Some properties of scheduling prob-
lem with storing constraints. Zeszyty Naukowe AGH:
Automatyka (in Polish), 34:223–232.
Taillard, E. (1993). Benchmarks for basic scheduling prob-
lems. European Journal of Operational Research,
64:278–285.
ICINCO 2005 - INTELLIGENT CONTROL SYSTEMS AND OPTIMIZATION
76