a tabu search algorithm for the flowshop scheduling problem with changing neighborhoods

Available online at www.sciencedirect.com

Computers & Industrial Engineering 54 (2008) 1–11

www.elsevier.com/locate/dsw

A tabu search algorithm for the flowshop schedulingproblem with changing neighborhoods

Burak Eks�ioglu a,*, Sandra Duni Eks�ioglu a, Pramod Jain b

a Department of Industrial and Systems Engineering, Mississippi State University, P.O. Box 9542, Mississippi State, MS 39762, USAb Sabre Airline Solutions, 3150 Sabre Drive, Southlake, TX 76092, USA

Received 3 May 2006; received in revised form 16 January 2007; accepted 11 April 2007Available online 13 April 2007

Abstract

Flowshop scheduling deals with the sequencing of a set of jobs that visit a set of machines in the same order. A tabusearch procedure is proposed for the flowshop scheduling problem with the makespan minimization criterion. Differentfrom other tabu search procedures, the neighborhood of a solution is generated using a combination of three differentexchange mechanisms. This has resulted in a well-diversified search procedure. The performance of the algorithm is testedusing Taillard’s benchmark problems. The results are compared to recently developed neuro-tabu search and ant colonyheuristics. The computational results indicate the effectiveness of the proposed approach.� 2007 Elsevier Ltd. All rights reserved.

Keywords: Flowshop; Scheduling; Tabu search; Heuristics; Neighborhood

1. Introduction

The classical flowshop problem with the makespan minimization criterion has always attracted the atten-tion of researchers because of its applications in practice. For example, a typical ship builder builds a numberof different ship models, but the individual parts that go into each ship follow similar processes. A shipyardcan be thought of as a collection of several flowshops. In particular, almost all parts, i.e. the big metal blocks,go through a panel shop in a ship yard where they are cut or welded together. Panel shops are typically treatedas flowshops. The flowshop problem is easy to describe and formulate, yet computationally it is rather chal-lenging. Therefore, this problem has inspired the development of a number of solution procedures.

The flowshop scheduling problem refers to the sequencing of a set of n jobs (tasks or items) to be processedon a set of m machines (or processors) in the same order. That is, the jobs are first processed on machine 1,then on machine 2, and so on until machine m. The objective is to find a sequence of the jobs to be processedon the machines so that the makespan is minimized. This problem is known to be NP-complete in the strongsense when m P 3 (Garey, Johnson, & Sethi, 1976). Johnson (1954) presents a simple algorithm that optimally

0360-8352/$ - see front matter � 2007 Elsevier Ltd. All rights reserved.doi:10.1016/j.cie.2007.04.004

* Corresponding author. Tel.: +1 662 325 7625; fax: +1 662 325 7618.E-mail address: [email protected] (B. Eks�ioglu).

mailto:[email protected]

2 B. Eks�ioglu et al. / Computers & Industrial Engineering 54 (2008) 1–11

solves the flowshop scheduling problem in polynomial time in the special case when m = 2. The complexity ofthe flowshop scheduling problem has encouraged the development of various heuristic methods that providefeasible permutations of the n jobs. Exact methods are simply not practical even for instances with few jobsand few machines. Reisman, Kumar, and Motwani (1994) and Ruiz and Maroto (2005) provide comprehen-sive reviews of flowshop scheduling problems.

The heuristic approaches for the flowshop problem are grouped into constructive heuristics and improve-

ment heuristics (Ruiz & Maroto, 2005). Constructive heuristics build a feasible schedule for a given set of n

jobs. For example, Johnson’s algorithm (Johnson, 1954) is a constructive algorithm. Most of the constructiveheuristics have extended the Johnson’s algorithm for the m-machine flowshop problem (Campbell, Dudek, &Smith, 1970; Koulamas, 1998; Sarin & Lefoka, 1993). The NEH algorithm developed by Nawaz, Enscore, andHam (1983) is regarded as the best constructive heuristic for the classical flowshop scheduling problem. On theother hand, the improvement heuristics start with a feasible schedule and try to improve the problem’s objec-tive considering problem-specific knowledge (Dannenbring, 1977; Ho & Chang, 1991; Suliman, 2000). Meta-heuristics such as simulated annealing (Osman & Potts, 1989; Ogbu & Smith, 1991), tabu search (Taillard,1990), genetic algorithms (Chen, Vempati, & Aljaber, 1995; Reeves, 1995), etc. have been used to generate fea-sible sequences for the flowshop problem.

We propose a tabu search approach for the flowshop scheduling problem. Tabu search has shown to besuccessful in solving the flowshop problem with makespan minimization criterion (Nowicki & Smutnicki,1996; Ben-Daya & Al-Fawzan. M., 1998; Grabowski & Wodecki, 2004; Solimanpur, Vrat, & Shankar,2004; Taillard, 1990; Widmer & Hertz, 1989). The concept behind tabu search is very simple. The algorithmstarts with an initial solution. The neighborhood of this solution is searched to identify a new neighbor towhich to move. The search procedure explores the solution space beyond local optimality by allowing movesto neighbors that have worse makespans. Key elements of the search path are selectively remembered (using atabu list), and strategic choices are made to guide the search out of local optima and into diverse regions of thesolution space. The algorithm ends when some stopping criterion is satisfied. Despite the simplicity of thisapproach – defining the neighborhood, the move strategies, the forbidden moves, the tabu list length, etc. –remains an art. Different implementations of these elements result in different tabu search algorithms. Themajor difference between our algorithm, called 3XTS, and other tabu search procedures proposed for the flow-shop problem is the neighborhood definition. The most common neighborhood types found in the literatureare the ones created by adjacent exchange, random exchange, and insertion. The 3XTS algorithm uses a com-bination of three different exchange mechanisms that are described in Section 3.2.

The proposed tabu search algorithm is tested using the problem set provided by Taillard (1993). The resultsare compared to the results of the EXTS algorithm proposed by Solimanpur et al. (2004) and the results of anant colony system proposed by Ying and Liao (2004).

2. Problem formulation

The flowshop scheduling problem with makespan criterion refers to the sequencing of a set of n jobs(J = {1, . . . ,n}) to be processed on a set of m machines (I = {1, . . . ,m}). Without loss of generality, assumethat the jobs are processed in the order of indices of machines. The time it takes to process job j on machinei is pji. A sequencing of jobs can be represented by a permutation p = (p(1), . . . ,p(n)), where p(a) is the athelement of permutation p. Let P denote the set of all such permutations. The objective is to find a permutationp* 2 P that minimizes the makespan (the completion time of the last job on the last machine):

Cmaxðp�Þ ¼ minp2P

CmaxðpÞ;

where Cmax(p) is the time required to complete the processing of all jobs on all machines following the sequencegiven by permutation p. Cmax(p) can be calculated using the following equation (Grabowski, 1979, 1982):

CmaxðpÞ ¼ max16t16...6tm�16n

Xt1

a¼1

ppðaÞ1 þXt2

a¼t1

ppðaÞ2 þ � � � þXn

a¼tm�1

ppðaÞm ð1Þ

The sequence of integers t = (t1, t2, . . . , tm�1) defines a path from node (1, 1) to (m,n) in a grid graph as theone presented in Fig. 1. We introduce the following equivalent makespan formulation:

3 7 6 1 8 5 2 4 1 2 3 4 5 6 7 8

Machine1

Job: Position:

2

3

4

5

Fig. 1. Grid graph of a flowshop problem with 5 machines and 8 jobs: modified from Nowicki and Smutnicki (1996).

B. Eks�ioglu et al. / Computers & Industrial Engineering 54 (2008) 1–11 3

CmaxðpÞ ¼ max16f16...6fn�16m

Xf1

i¼1

ppð1Þi þXf2

i¼f1

ppð2Þi þ � � � þXm

i¼fn�1

ppðnÞi ð2Þ

where the sequence of integers (f1, f2, . . . , fn�1) defines the same path t as given in Eq. (1). For example, in theflowshop problem given in Fig. 1, t = (t1, t2, t3, t4) = (3, 5,5,7) and also t = (f1, f2, . . . , f7) = (1, 1,2,2,4,4,5). Thecritical path is the longest path in the graph and its length gives the makespan. This implies thatCmax(p) P C(p, t) for all t, where C(p, t) is the length of a path t for a given permutation p.

Each path is comprised of horizontal and vertical sub-paths. Each sub-path is called a block. There are m

horizontal and n vertical blocks on every path. While the concept of blocks have been used in the literature, wemodify the definition of blocks and rename it as horizontal blocks. We also introduce vertical blocks. The fol-lowing block definitions are used later in Section 3 in defining the neighborhood. Let HBi be the ith horizontalblock on path t, then HBi = {p(ti�1),p(ti�1 + 1), . . . ,p(ti)}, i = 1, . . . ,m, t0 = 1 and tm = n. In Eq. (1) there arem summation terms, each corresponding to a horizontal block. Similarly, let VBa be the ath vertical block onpath t, then VBa = {fa�1, fa�1 + 1, . . . , fa}, a = 1, . . . ,n, f0 = 1 and fn = m. Thus, each term in Eq. (2) corre-sponds to a vertical block.

The horizontal blocks have certain properties that have been explored to design efficient tabu search pro-cedures. Grabowski (1979, 1982) has shown that changing the position of a job within a block will not lead toa permutation with a better makespan. Nowicki and Smutnicki (1996) show that the insertion of jobs in theadjacent blocks is promising. We use similar properties (see Section 3.2) to search promising neighbors effi-ciently rather than search the whole neighborhood.

3. Elements of the tabu search approach

The tabu search approach for combinatorial optimization problems was first proposed by Glover (1989, 1990).This meta-heuristic starts with an initial solution p and then searches its neighborhood to identify the most appro-priate neighbor to which to move. A neighbor p 0 is chosen if it is not tabu (i.e. not in the tabu list K) or if an aspi-ration criterion is satisfied. The move function transformsp intop 0 even ifp 0 is not a better solution. The tabu list Kstores all the forbidden moves. The size of K is bound by a parameter l, called tabu list size. When |K| = l, beforeadding a new element to K, the oldest element is removed from the list. An aspiration criterion could be such that itallows a tabu move when the neighbor has an objective function value better than the best objective encountered sofar. The size l of the tabu list could be fixed or could dynamically change through certain adjustments.

3.1. Initial solution

A constructive approach is used to yield an initial solution. Based on the recent review of flowshop heuris-tics by Ruiz and Maroto (2005), the NEH algorithm provided by Nawaz et al. (1983) is the best heuristic forTaillard’s benchmark problems (Taillard, 1993). Since we analyzed the performance of our algorithm on thesame set of problems, we adopted the NEH algorithm to generate initial solutions.


3.2. Neighborhood definition

In the classical flowshop problem a solution is represented by a permutation of the jobs. A neighborhoodfor a given solution is defined as the set of all permutations that can be created by a certain perturbation of thecurrent solution. Adjacent exchange, random exchange, and insertion are three different perturbation schemesthat have been used in most of the existing algorithms that are developed for the flowshop scheduling problem.These perturbation schemes can be formally defined as follows:

• Adjacent exchange: exchange the positions of the jobs currently in positions a and (a + 1).• Random exchange (two exchange): exchange the positions of the jobs currently in positions a and b.• Insertion: remove the job currently in position a and insert it into position b.

Taillard (1990) has experimentally shown that the insertion scheme is more efficient and effective. There-fore, most of the subsequent algorithms (e.g. Grabowski & Wodecki, 2004; Nowicki & Smutnicki, 1996; Sol-imanpur et al., 2004) have used the insertion neighborhood. Another reason the insertion scheme is preferredis perhaps because the size of the neighborhood is smaller under this scheme compared with three or moreexchange schemes.

In the proposed tabu search algorithm, three perturbation schemes are used interchangeably: threeexchange (3EX), two exchange (2EX), and insertion (INS). 2EX is the scheme described above as randomexchange. INS is similar to the scheme described above as insertion. It has been shown that inserting a jobinto adjacent blocks is promising. Therefore, INS is redefined as follows:

Definition 1. Let p be the current solution under investigation. A neighbor of p using the INS scheme isobtained by inserting the job in position a (where p(a) 2 HBi) into position b. The values b can take arepresented in Table 1.

In 3EX three jobs are randomly picked and their positions are interchanged.Definition 2. Let p be the current solution. A neighbor of p using the 3EX scheme is obtained by exchangingthe jobs in positions a, b, and c (for a < b < c or a > b > c). Job p(a) is moved to position b, p(b) is moved toposition c, and p(c) is moved to a.

Based on the definitions given above, it is easy to show that the size of the 3EX neighborhood is nðn�1Þðn�2Þ3

,the size of the 2EX neighborhood is nðn�1Þ

2, and the size of the INS neighborhood is 2n. To present the 3EX,

2EX, and INS neighborhoods more precisely let us consider the example given in Fig. 1. In this example thecurrent solution is p = (3, 7,6,1,8,5,2,4). To generate a neighbor using the 3EX mechanism we need threenumbers a, b, and c that represent the positions of the jobs that will be exchanged. Let a = 2, b = 5, andc = 6, then the neighbor corresponding to (2, 5,6) would be p 0 = (3,5,6,1,7,8,2,4). Note that (2,5,6),(6,2,5), and (5,6,2) will all lead to the same neighbor. Thus, it is sufficient to only consider (a,b,c) values suchthat a < b < c or a > b > c.

To generate a neighbor using the 2EX mechanism we need two numbers a and b that represent the positionsof the jobs that will be exchanged. Let a = 2 and b = 5, then the neighbor corresponding to (2, 5) would be

Table 1Perturbation scheme for the INS neighborhood

Possible positions

i = 1 a = t1 t0 tfa

Otherwise t1

1 < i < m a = ti�1 tfa�1�1 ti

a = ti ti�1 tfa

Otherwise ti�1 ti

i = m a = tm�1 tfa�1�1 tm

Otherwise tm�1


p 0 = (3, 8,6,1,7,5,2,4). Note that (2,5) and (5, 2) will lead to the same neighbor. Thus, it is sufficient to onlyconsider (a,b) values such that a < b.

To generate a neighbor using the INS mechanism we need two numbers a and b where a represents theposition of the job that will inserted into position b. Let a = 2 and b = 5, then the neighbor correspondingto (2, 5) would be p 0 = (3,6,1,8,7,5,2,4). Note that based on Fig. 1, Table 1 and the INS definition givenabove, the possible (a,b) values for p = (3,7,6,1,8,5,2,4) would be (1,3), (2, 3), (3, 1), (3,5), (4, 3), (4,5),(5,3), (5, 7), (6,5), (6, 7), (7,5), (7, 8), and (8,7).

As mentioned above, the sizes of the 3EX, 2EX, and INS are, respectively, in the order of O(n3), O(n2), andO(n). In local search algorithms, as a rule of thumb, the larger the neighborhood, the better the quality of thesolution obtained. On the other hand, however, the larger the neighborhood, the longer it takes to search theneighborhood at each iteration. Therefore, a larger neighborhood does not necessarily lead to a more effectiveheuristic unless the neighborhood can be searched in an efficient manner. The 3EX, 2EX, and INS neighbor-hoods can be efficiently searched by using the block properties and the move strategy given below. Asdescribed in the computational results section, using the three different schemes interchangeably rather thanusing 3EX, 2EX or INS alone leads to better solutions. Let D3EX, D2EX, and DINS be as follows:

D3EX ¼X

k2VBa

ðppðcÞk � ppðaÞkÞ þX

k2VBb

ðppðaÞk � ppðbÞkÞ þX

k2VBc

ðppðbÞk � ppðcÞkÞ

D2EX ¼X

k2VBa

ðppðbÞk � ppðaÞkÞ þX

k2VBb

ðppðaÞk � ppðbÞkÞ

DINS ¼

Pk2VBa

ðppðaþ1Þk � ppðaÞkÞ þP

k2VBb

ðppðaÞk � ppðbÞkÞ if a < b

þppðbÞfb�1� ppðaþ1ÞfaP

k2VBa

ðppða�1Þk � ppðaÞkÞ þP

k2VBb

ðppðaÞk � ppðbÞkÞ if a > b

þppðbÞfb� ppða�1Þfa�1

8>>>>><>>>>>:

Theorem 1. Let p 2 P, t� ¼ ðf �1 ; f �2 ; . . . ; f �n�1Þ be a critical path with respect to p, and p 0 be a permutation

obtained from p using the 3EX scheme. Then, the following holds:

0
Cmaxðp ÞP CmaxðpÞ þ D3EX
Proof. Assume that a < b < c, then

CmaxðpÞ þ D3EX ¼Xf �1k¼1

ppð1Þk þ � � � þXf �a

k¼f �a�1

ppðaÞk þ � � � þXf �b

k¼f �b�1

ppðbÞk þ � � � þXf �c

k¼f �c�1

ppðcÞk

þ � � � þXm

k¼f �n�1

ppðnÞk þXf �a

k¼f �a�1

ðppðcÞk � ppðaÞkÞ þXf �b

k¼f �b�1

ðppðaÞk � ppðbÞkÞ

þXf �c

k¼f �c�1

ðppðbÞk � ppðcÞkÞ

¼Xf �1k¼1


k¼f �a�1

ppðcÞk þ � � � þXf �b

k¼f �b�1

ppðaÞk þ � � � þXf �c

k¼f �c�1

ppðbÞk

þ � � � þXm

k¼f �n�1

ppðnÞk


Let t ¼ ðf �1 ; f �2 ; . . . ; f �n�1Þ be a path with respect to p 0. Then, we have

Cðp0; tÞ ¼Xf �1k¼1


k¼f �a�1

ppðcÞk þ � � � þXf �b

k¼f �b�1

ppðaÞk þ � � � þXf �c

k¼f �c�1

ppðbÞk þ � � � þXm

k¼f �n�1

ppðnÞk

By definition,

Cmaxðp0ÞP Cðp0; tÞ ¼ CmaxðpÞ þ D3EX

The proof for the case a > b > c is similar. h

Theorem 2. Let p 2 P, t� ¼ ðf �1 ; f �2 ; . . . ; f �n�1Þ be a critical path with respect to p and p 0 be a permutation obtained

from p using the 2EX scheme. Then, the following holds:

Cmaxðp0ÞP CmaxðpÞ þ D2EX

Theorem 3. Let p 2 P, t� ¼ ðf �1 ; f �2 ; . . . ; f �n�1Þ be a critical path with respect to p and p 0 be a permutation

obtained from p using the INS scheme. Then, the following holds:

Cmaxðp0ÞP CmaxðpÞ þ DINS

The proof of Theorem 2 is omitted since it is similar to the proof of Theorem 1. The proof of Theorem 3 isomitted because it is similar to the proofs of Theorems 2 and 3 in their paper presented by Grabowski andWodecki (2004).

In exploring the neighborhood of a solution p, the value of DX for a neighbor p 0 is calculated, whereX 2 {3EX, 2EX, INS} is the scheme used to obtain p 0 from p. Calculating DX takes O(m) in the worst case,but in most cases it is O(1). On the other hand, makespan calculation takes O(nm). If DX P 0, the new neigh-bor is not worth exploring because based on Theorems 1–3 its makespan will not be better than the currentmakespan. This results in significant computational savings.

3.3. Move strategy

The move strategy determines the manner in which the neighbors are visited. There are primarily twomove strategies: best and first-better. The best move strategy may lead to better solutions, but computation-ally it is not efficient because all possible neighbors are evaluated and a move is made to the one with thebest makespan. With the first-better strategy, the neighbors are evaluated one at a time and a move is madeas soon as a better solution is found. Since the 3EX neighborhood is relatively large, we use the first-bettermove strategy.

3.4. Tabu list

The tabu list is one of the mechanisms to prevent cycling and guide the search toward unexplored regions ofthe solution space. Glover (1989, 1990) provides some general methods of tabu list implementations. Amongseveral tabu search implementations, those of Nowicki and Smutnicki (1996), Grabowski and Wodecki (2004),and Solimanpur et al. (2004) are the most recent. Nowicki and Smutnicki (1996) apply a tabu list which storesattributes of the visited permutation defined by certain pair of adjacent jobs. Grabowski and Wodecki (2004)add pairs of jobs to their tabu list representing a precedence constraint. For example, if pair (3,5) is in the tabulist, then all permutations where job 3 precedes job 5 are considered tabu and not explored. Solimanpur et al.(2004) implement a neural network-based tabu search. They do not have an explicit tabu list, but all moves arerepresented as neurons. In this way the tabu effect of a move reduces exponentially rather than completelydisappearing after a fixed number of iterations. The advantage of this approach is that it eliminates the tedioustrial-and-error process of finding a proper tabu list size. However, the disadvantage is that it requires allocat-ing memory to keep track of the tabu status of all moves. For large neighborhoods this may become a prob-lem. Another disadvantage is that the tabu status does not include any information about the jobs. For


example, if move (3,5) has a high tabu value, then the algorithm will try not to move the job in position 3 toposition 5 regardless of which job is in position 3. In our case, we keep three tabu lists of fixed size, one foreach of the three neighborhoods. The elements in the tabu list indicate whether a job is allowed in a certainposition. For example, if (3,5) is an element in the tabu list, then all permutations that have job 3 in position 5are forbidden. Once the list is full, the oldest element of the tabu list is removed as a new one is added.

3.5. Stopping condition

To terminate the tabu search procedure, the 3EX, 2EX, and INS neighborhoods are explored for a fixednumber of times. The algorithm initially starts with the 3EX neighborhood and searches for better solutions.After the algorithm explores the neighborhood of the current solution, if no better solution is found, then itmoves to the best neighboring solution even if it has a worse makespan than the current solution. Such movesare counted as bad moves. After a certain number of bad moves, the algorithm switches to the 2EX neighbor-hood and then to the INS neighborhood. This procedure continues for a fixed number of times and finally thealgorithm terminates.

3.6. Description of the algorithm

The abovementioned elements of the tabu search approach are combined to create the tabu search algo-rithm presented in Fig. 2. The algorithm starts by initializing the parameters and generating an initial solution.First, the 3EX neighborhood is explored in search of a better solution. Next, in order to diversify the search,the 2EX and INS neighborhoods are consecutively explored. The diversification scheme of moving from oneneighborhood to another is performed MaxCounter times. The details of the 3EX search algorithm are pre-sented in Fig. 3. The 2EX and INS algorithms are not presented here as they are similar to the 3EX algorithm.

The 3EX algorithm explores the neighbors of a current solution p individually (in random order) to identifya solution p 0 to which to move. In this process, the algorithm keeps track of the current solution p, the neigh-boring solution being investigated p 0, the best solution found so far p*, the best neighboring solution pNB anda list of forbidden moves K. For each solution, the corresponding makespan is calculated.

Based on Theorem 1, only the neighbors that have a negative D3EX are worth exploring. Initially, for aneighboring solution p 0 (p 0 62 K) D3EX is calculated. If D3EX is negative, then the corresponding makespan(Cmax(p 0)) is calculated.

If the makespan of p 0 is smaller than the makespan of the current solution p, we move to this neighboringsolution, update the tabu list, set the number of neighbors visited (NBcnt) to zero and start the search for a newneighboring solution. Furthermore, if the makespan of p 0 is smaller than the best makespan (Cmax(p*)) foundso far, then the best solution p* is updated.

If the makespan of p 0 is not smaller than the makespan of the current solution p, the number of neighborsvisited, NBcnt, is increased by one. In this case, if the corresponding makespan is smaller than the best neigh-boring makespan (Cmax(pNB)), the best neighboring solution found (pNB) is updated. When a maximum num-ber of neighbors (MaxNB) is visited, the algorithm moves to the best neighboring solution found so far bymaking a bad move. The 3EX algorithm terminates when the number of bad moves reaches MaxBad.

Fig. 2. The 3XTS algorithm.

Fig. 3. The 3EX search algorithm.


4. Computational results

To test the effectiveness of the proposed tabu search algorithm, 3XTS, we used the benchmark problemsprovided by Taillard (1993). Solimanpur et al. (2004) recently proposed a neuro-tabu search algorithm namedEXTS. They compared their results with those obtained by the BF-TS algorithm, which is a tabu searchmethod proposed by Ben-Daya and Al-Fawzan. M. (1998). The results indicate that the EXTS algorithm ismore effective and efficient than the BF-TS method. Moreover, BF-TS is shown to be better than the geneticalgorithm proposed by Reeves (1995) and the simulated annealing-based algorithms developed by Osman andPotts (1989) and Ogbu and Smith (1991) for the flowshop scheduling problem. Therefore, the results of the3XTS algorithm are compared to those obtained by EXTS and given in Table 2. The makespan and compu-tation time of EXTS are provided by Solimanpur et al. (2004) when a (the scaling factor they use) is equal to 8.EXTS is coded in Borland C++ and run on a 550 MHz Pentium III PC. Thus, for a fair comparison the 3XTSalgorithm is coded in C and run on a 550 MHz Pentium III PC.

There are a total of 120 problems of 12 different sizes in Taillard’s benchmark set. In Table 2 results for only23 of them are presented because the EXTS and BF-TS comparison is based on these 23 problems. Themakespans with * in the table indicate that an optimal solution was found. For most of the small-size prob-lems (1–15) and some of the large-size problems (16–23), both algorithms find optimal solutions. Therefore, acomparison of their computational times is given in the last column of Table 2. The gap shows the percentimprovement achieved in the computational time by using the 3XTS algorithm instead of EXTS. The param-eter values used in the 3XTS algorithms were set to the following values after tuning: MaxCounter = 3; for3EX MaxBad = 10m, l = 60, MaxNB = 6n; for 2EX MaxBad = 20m, l = 20, MaxNB = 4n; and for INS Max-Bad = 30m, l = 7, MaxNB = 2n.

A set of initial experiments were conducted using the INS, 2EX or 3EX search algorithms alone. The resultsfrom these experiments were not as good as the results obtained when the three search schemes were usedinterchangeably as described in Fig. 2. This is due to the diversification of the search by moving from oneneighborhood type to the other. As can be seen from Table 2, the 3XTS algorithm finds a better solutionfor seven problems, whereas the opposite is true for only one problem. Moreover, 3XTS is faster than EXTSin all but two of the problems. The average reduction in computational time is about 50%.

The promising results encouraged us to run additional experiments considering all 120 problems of Tail-lard’s benchmark set. For the new set of experiments MaxCounter is set to 10m2/n, and 3XTS is run on a3.2 GHz Pentium 4 PC. The results are compared to the solutions obtained by the ant colony system(ACS) of Ying and Liao (2004). Through their computational experiments, Ying and Liao (2004) show thattheir ACS outperforms GA, SA, and NS algorithms of Reeves (1995). ACS is run on an AMD 700 MHz PC.To make a fair comparison we adjusted the CPU time of ACS. Based on CPU speed comparison charts pro-vided by PassMarkSoftware (2007), an AMD 700 MHz PC is approximately four to five times slower than a3.2 GHz Pentium 4 PC. Therefore, the times reported by Ying and Liao (2004) have been divided by five in

Table 2Computational results for EXTS and 3XTS algorithms

Problem Size n/m EXTS 3XTS Gap(%)

Cmax Time Cmax Time

1-ta01 20/5 1278* 1.30 1278* 0.32 75.382-ta02 1359* 1.50 1359* 0.41 72.663-ta03 1081* 2.20 1081* 0.72 67.274-ta04 1293* 3.00 1293* 1.30 56.675-ta05 1235* 1.50 1235* 0.36 76.00

6-ta11 20/10 1582* 5.20 1582* 2.13 59.037-ta12 1659* 11.10 1659* 4.61 58.468-ta13 1499 5.20 1496* 3.87 25.579-ta14 1378 8.50 1377* 3.92 1.1710-ta15 1419* 5.40 1419* 2.36 5.19

11-ta21 20/20 2297* 22.40 2297* 0.89 96.0212-ta22 2101 31.50 2103 6.36 79.8013-ta23 2330 19.50 2330 7.62 60.9214-ta24 2229 17.80 2229 51.37 69.8315-ta25 2291* 25.20 2291* 8.92 64.60

16-ta31 50/5 2724* 0.82 2724* 0.56 31.7017-ta41 50/10 3034 4.60 3025 7.30 �58.6918-ta51 50/20 3893 575.40 3893 15.45 97.31

19-ta61 100/5 5493* 4.90 5493* 3.24 33.8720-ta71 100/10 5771 19.30 5770* 16.32 18.2521-ta81 100/20 6326 242.80 6300 61.24 74.77

22-ta91 200/10 10,872 154.40 10,869 221.32 �43.3423-ta101 200/20 11,326 421.50 11,251 320.67 23.92

* Indicates optimal value.


Table 3 in which time is reported in CPU seconds. Table 3 also provides a comparison of ACS with 3XTS inwhich quality is measured by the mean percent difference from Taillard’s upper bound. In other words, foreach problem size, quality is reported as the average percent deviation of the ten problem instances whichis calculated as follows:

TableCompa

Proble

20/520/1020/2050/550/1050/20100/5100/10100/20200/10200/20500/20

Averag

Quality ¼ 100ðCH � CTÞ=CT

3rison of ACS and 3XTS algorithms

m ACS 3XTS

Quality Adjusted time Quality Time

1.19 2.20 �0.04 0.281.70 2.40 0.00 5.301.60 3.20 0.00 96.620.43 8.80 �0.01 0.391.89 10.80 �0.63 13.332.71 14.60 �0.43 238.570.22 32.60 �0.03 0.581.22 39.40 �0.25 17.602.22 52.80 �1.21 448.030.64 165.20 �0.21 27.771.30 379.00 �1.55 828.891.68 3079.80 �0.69 1800.41

e 1.40 315.90 �0.42 289.79

Table 4Optimal solutions found by algorithms T and 3XTS

Problem Optimal known Optimal found

T 3XTS

20/5 10 9 1020/10 10 10 1020/20 10 10 1050/5 10 8 1050/10 10 0 250/20 0 0 0100/5 10 6 10100/10 10 0 7100/20 1 0 0200/10 10 0 8200/20 6 0 0500/20 7 0 0

Total 94 43 67


where CH is the makespan obtained by algorithm H, i.e. H 2 {ACS, 3XTS}, and CT is the reference makespanobtained by algorithm T of Taillard (1993).

As can be seen from Table 3, the average CPU time of 3XTS is slightly lower than that of ACS. Also, thequality of the solutions obtained from 3XTS is much better compared to the ones ACS provides. Thus, we canclaim that 3XTS outperforms ACS. Another interesting observation is that the CPU times of ACS are strictlyincreasing whereas the CPU times of 3XTS are increasing for a given number of machines. Clearly, thisdepends on the specific implementation of the algorithms. However, it is important to note that the problemswith five machines (m = 5) are much easier compared to the others. As a matter of fact 3XTS find the optimalsolutions for all 30 of the five machine problems.

As of January 2007, optimal solutions are known for 94 of the 120 Taillard problems (Taillard’sPage,2007). Table 4 shows the number of optimal solutions known for each problem size along with the optimalsolutions found by algorithm T of Taillard (1993) and 3XTS. Table 4 is provided to make the quality valuesof Table 3 more meaningful. For example, for 20/5, 3XTS finds all ten of the optimal solutions but T findsonly nine, and the quality value for 3XTS is �0.04. This means that 3XTS was able to find the optimal solu-tion for one of the problems that algorithm T has missed. For 20/10 and 20/20, the corresponding quality val-ues are both zero for 3EXTS (see Table 3). Looking at Table 4, we realize that the quality values are zerobecause both T and 3XTS found the optimal solutions for all of those 20 problems.

5. Conclusion

This paper presents a tabu search algorithm for the flowshop problem with makespan minimization crite-rion. The proposed 3XTS algorithm has been tested on Taillard’s benchmark problems and compared torecently published ant colony (ACS) and tabu search (EXTS) algorithms.

Tabu search has shown to be a successful heuristic in solving the problem. The main difference between the3XTS and other tabu search algorithms developed for the flowshop problem is that 3XTS diversifies the searchfor a better solution by utilizing three different neighborhood structures. The tabu search algorithms revieweduse a single neighborhood structure. In addition, the neighborhoods are efficiently searched by consideringonly the most promising neighbors. This is achieved by utilizing the block properties of the flowshop problem.While block properties for the INS scheme have been explored in the literature, we provide block propertiesfor the 2EX and 3EX schemes.

The computational results indicate that 3XTS provides as good solutions as EXTS for small-size instances,but it outperforms the EXTS algorithm in large-size problems. Due to the fact that 3XTS explores the blockproperties, the running time of the algorithm is about 50% smaller than EXTS. On average the running timesof ACS and 3XTS are about the same, but 3XTS finds solutions that are much more closer to the optimal.


References

Ben-Daya, M., & Al-Fawzan, M. (1998). A tabu search approach for the flow shop scheduling problem. European Journal of Operational

Research, 109, 88–95.Campbell, H. G., Dudek, R. A., & Smith, M. L. (1970). A heuristic algorithm for the n job, m machine sequencing problem. Management

Science, 16, 630–637.Chen, C. L., Vempati, V. S., & Aljaber, N. (1995). An application of genetic algorithms for flowshop problems. European Journal of

Operational Research, 80, 389–396.Dannenbring, D. G. (1977). An evaluation of flow shop sequencing heuristics. Management Science, 23, 1174–1182.Garey, M., Johnson, D., & Sethi, R. (1976). The complexity of flowshop and jobshop scheduling. Mathematics of Operations Research, 1,

117–129.Glover, F. (1989). Tabu search: part I. ORSA Journal on Computing, 1, 190–206.Glover, F. (1990). Tabu search: part II. ORSA Journal on Computing, 2, 4–32.Grabowski, J. (1979). Generalized problems of operations sequencing in the discrete production systems. Monographs 9, 1979. Scientific

Paper of the Institute of Technical Cybernetics of Wroclaw Technical University.Grabowski, J., Operations research in progress. (1982). Dordrecht: Reidel Publishing Company, Ch. A new algorithm of solving the flow-

shop problem, pp. 57–75.Grabowski, J., & Wodecki, M. (2004). A very fast tabu search algorithm for the permutation flow shop problem with makespan criterion.

Computers & Operations Research, 31(11), 1891–1909.Ho, J. C., & Chang, Y. L. (1991). A new heuristic for the n-job, m-machine flowshop problem. European Journal of Operational Research,

52, 194–202.Johnson, S. (1954). Optimal two and three stage production schedules with set-up times included. Naval Research Logistics Quarterly, 1(1),

61–68.Koulamas, C. (1998). A new constructive heuristic for the flowshop scheduling problem. European Journal of Operational Research, 105,

66–71.Nawaz, M., Enscore, E. E., Jr., & Ham, I. (1983). A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem. Omega,

11(1), 91–95.Nowicki, E., & Smutnicki, C. (1996). A fast tabu search algorithm for the permutation flow-shop problem. European Journal of

Operational Research, 91, 160–175.Ogbu, F. A., & Smith, D. K. (1991). Simulated annealing for the permutation flowshop problem. Omega, 19(1), 64–67.Osman, I., & Potts, C. (1989). Simulated annealing for the permutation flowshop scheduling. Omega, 17, 551–557.PassMarkSoftware, January 2007. http://www.passmark.com/cpureview/fpmaths.htm.Reeves, C. R. (1995). A genetic algorithm for flowshop sequencing. Computers & Operations Research, 22(1), 5–13.Reisman, A., Kumar, A., & Motwani, J. (1994). Flowshop scheduling/sequencing research: A statistical review of the literature. IEEE

Transactions on Engineering Management, 44, 316–329.Ruiz, R., & Maroto, C. (2005). A comprehensive review and evaluation of permutation flowshop heuristics. European Journal of

Operational Research, 165, 479–494.Sarin, S. & Lefoka, M. (1993). Scheduling heuristic for the n-job m-machine flow shop 21(2), 229–234.Solimanpur, M., Vrat, P., & Shankar, R. (2004). A neuro-tabu search heuristic for the flow shop scheduling problem. Computers &

Operations Research, 31, 2151–2164.Suliman, S. (2000). A two-phase heuristic approach to the permutation flowshop scheduling problem. International Journal of Production

Economics, 64, 143–152.Taillard, E. (1993). Benchmarks for basic scheduling problems. European Journal of Operational Research, 64, 278–285.Taillard, E. (1990). Some efficient heuristic methods for the flow shop sequencing problem. European Journal of Operational Research, 47,

65–67.Taillard’sPage, January 2007. http://ina2.eivd.ch/Collaborateurs/etd/problemes.dir/ordonnancement.dir/ordonnancement.html.Widmer, M., & Hertz, A. (1989). A new heuristic method for the flow shop sequencing problem. European Journal of Operational

Research, 41, 186–193.Ying, K., & Liao, C. (2004). An ant colony system for permutation flow-shop sequencing. Computers & Operations Research, 31, 791–801.

http://www.passmark.com/cpureview/fpmaths.htm

http://ina2.eivd.ch/Collaborateurs/etd/problemes.dir/ordonnancement.dir/ordonnancement.html

a tabu search algorithm for the flowshop scheduling problem with changing neighborhoods

Documents