a discrete group search optimizer for blocking flow shop multi objective scheduling

88 1–9 Ó The Authors 2016 DOI: 10.1177/1687814016664262 aime.sagepub.com A discrete group search optimizer for blocking flow shop multi-objective scheduling Deng Guanlong, Zhang Shuning

Advances in Mechanical Engineering

2016, Vol 8(8) 1–9

Ó The Author(s) 2016 DOI: 10.1177/1687814016664262 aime.sagepub.com

A discrete group search optimizer for

blocking flow shop multi-objective

scheduling

Deng Guanlong, Zhang Shuning and Zhao Mei

Abstract

This article presents a multi-objective discrete group search optimizer for blocking flow shop multi-objective scheduling problem The algorithm is designed to search the Pareto-optimal solutions minimizing the makespan and total flow time for the flow shop scheduling with blocking constraint In the proposed algorithm, a diversified initial population is con-structed based on the Nawaz–Enscore–Ham heuristic and its variants Unlike the original group search optimizer in which continuous solution representation is used, the proposed algorithm employs discrete job permutation representa-tion to adapt to the considered scheduling problem Accordingly, operarepresenta-tions of producer, scrounger, and ranger are newly designed An insertion-based Pareto local search is put forward in producer procedure, a crossover operation is introduced in scrounger procedure, and a local search based on the insert neighborhood is designed in ranger proce-dure A bunch of computational experiments and results show that the proposed algorithm is superior to two existing powerful meta-heuristics in terms of both inverted generational distance and set coverage

Keywords

Meta-heuristics, flow shop, multi-objective, blocking, scheduling

Date received: 26 January 2016; accepted: 19 July 2016

Academic Editor: Xichun Luo

Introduction

Scheduling problems play an important role in

indus-trial engineering and operation research and have

attracted widespread scientific attention these years

Two common problems which frequently appear in the

scheduling literature are the permutation flow shop

scheduling problem (PFSP)1,2and job shop scheduling

problem (JSP).3–5 The PFSP assumes that there are

enough intermediate buffers for jobs between two

con-secutive machines, whereas the buffers are limited in

real production If there is no buffer for a job and the

next machine is busy, then the job has to stay on the

incumbent machine and block itself Assume that the

buffer size is zero between any two consecutive

machines, a job is easy to block itself and hence the

production is greatly delayed Such a problem is called

the blocking flow shop scheduling problem (BFSP)

The BFSP extensively exists in all sorts of industrial environments, such as petrochemical process, batch process, plastics molding, and steel manufacture.6,7

A great deal of research work has been done on the BFSP It was proved to be non-deterministic polyno-mial-time (NP)-hard for minimizing makespan for the case of more than two machines.8 In 2007, Companys and Mateo9proposed a branch and bound method for makespan minimization in the BFSP, and they solved the problem instances with small sizes Hybridizing the

School of Information and Electrical Engineering, Ludong University, Yantai, China

Corresponding author:

Deng Guanlong, School of Information and Electrical Engineering, Ludong University, Yantai 264025, China.

Email: dglag@163.com

Creative Commons CC-BY: This article is distributed under the terms of the Creative Commons Attribution 3.0 License

(http://www.creativecommons.org/licenses/by/3.0/) which permits any use, reproduction and distribution of the work without further permission provided the original work is attributed as specified on the SAGE and Open Access pages (https://us.sagepub.com/en-us/nam/ open-access-at-sage).

dynamic programming and branch and bound

meth-ods, Bautista et al.10presented a bounded dynamic

pro-gramming method, and the method was effective for

small-size instances but powerless to solve instances

with large sizes As regards the heuristic, there were

profile fitting (PF),11 Nawaz–Enscore–Ham (NEH),12

minmax (MM), the hybridization of MM and NEH

(MME), and the hybridization of PF and NEH

(PFE).13 In recent years, meta-heuristics have been an

extensively used method for the scheduling field To

minimize the makespan in the BFSP, a genetic

algo-rithm was proposed by Caraffa et al.,14 and a tabu

search was presented by Grabowski and Pempera.15

Besides, some other algorithms, including the hybrid

discrete differential evolution algorithm,16 the iterated

greedy algorithm,17 and the hybrid harmony search

algorithm,18 were put forward To minimize the total

flow time in BFSP, Deng et al.19 introduced a hybrid

discrete artificial bee colony algorithm which achieved

good performance

The above existing researches are oriented to a single

criterion, while multi-objective scheduling problems

have gained increasing focus since multiple criteria are

usually encountered in real-life scheduling problems

For the multi-objective JSP, Gao et al.20 proposed a

Pareto-based grouping discrete harmony search

algo-rithm and a discrete harmony search algoalgo-rithm.21For

the multi-objective PFSP, Yenisey and Yagmahan22

provided an extensive review Although the

multi-objective PFSP is widely studied by many researchers,

there are less research reports for the multi-objective

optimization in the BFSP This article considers the

minimization of both makespan and total flow time

and presents a multi-objective discrete group search

optimizer (MDGSO) to search the Pareto-optimal

solutions

Multi-objective BFSP

In BFSP, there are n jobs (job j, j = 1, 2, , n) and m

machines (machine Mi, i= 1, 2, , m) Each job has to

be processed first on machine M1, then on machine M2,

., and finally on machine Mm The processing time of

job j on machine Miis known as p(j, i) The blocking

constraint exists in the production process, which means

there is no buffer between any two consecutive machines

To be specific, the following assumptions are given: (1) at

any time, a machine is able to process at most one job, and

a job is able to be processed on at most one machine; (2)

no job splitting is allowed; (3) all the jobs and machines are

available at time zero; and (4) the set-up time, release time,

and transfer time are omitted

A Gantt chart of BFSP with four jobs and three

machines is shown in Figure 1, where the blocking time

is marked as shadow rectangles In Figure 1, the job

sequence is 1-2-3-4, which consequently results in the makespan 22 and total flow time 62 It is worth noting that a job sequence different from 1-2-3-4 probably causes the changes of makespan and total flow time, and there is contradiction between these two objectives Assuming that we have two different schedules pa and

pband the makespan of pais less than that of pb, there

is a possibility that the blocking time in schedule pa is more than that in schedule pb, and hence for some jobs, the completion time in schedule pais more than that in schedule pb, making the total flow time of schedule pa more than that of schedule pb

The minimization criteria in this article are make-span and total flow time For the considered multi-objective BFSP, the feasible solution is represented as job permutation p =fp(1), p(2), , p(n)g, where pj denotes a job number Let dp(j), i denote the departure time of job p(j) from machine Mi, then we can compute the departure time first for p(1), then for p(2), and so

on until p(n) as follows

dp(1), i= dp(1), i1+ pp(1), i, i = 1, , m 1 ð2Þ

dp(j), 0= dp(j1), 1, j = 2, , n ð3Þ

dp(j), i= maxfdp(j), i1+ pp(j), i, dp(j1), i + 1g,

j = 2, , n, i = 1, , m 1 ð4Þ

dp(j), m= dp(j), m1+ pp(j), m, j = 1, , n ð5Þ where dp(j), 0 denotes the start time of p(j) on machine M1

Let f1(p) and f2(p) denote the objective value of makespan and total flow time of permutation p, respec-tively, then we have

f1(p) = dp(n), m ð6Þ

f2(p) = Xn

j = 1

These two objective values can be computed in O(mn) time Let P denote the set of all the job permu-tations, the multi-objective BFSP is formulated as

Figure 1 Gantt chart of a BFSP example.

Minimizeff1(p), f2(p)g for all p 2 P ð8Þ

Pareto domination states that solution padominates

solution pb if and only if8i 2 f1, 2g, fi(pa) fi(pb) and

9i 2 f1, 2g, fi(pa)\fi(pb) Solution pa is optimal in the

Pareto sense if there is not any solution pbwhich

domi-nates pa Pareto-optimal set is the set containing all

Pareto-optimal solutions and Pareto front is the set of

all objective values corresponding to the solutions in

the Pareto-optimal set

This article aims to solve the multi-objective

prob-lem by Pareto-optimal approach and propose a newly

designed algorithm for the considered problem

MDGSO

The group search optimizer (GSO) was first presented

for the continuous function optimization.23 The

popu-lation of the GSO consists of three roles: producers,

scroungers, and rangers, and each role has its specific

updating mechanism Producers perform producing

strategy by simulating the animal scanning mechanism,

scroungers perform scrounging strategy by joining

resources uncovered by others, and ranger search for

the resources by random walks In each generation, the

best member is selected as the producer, and certain

individuals in the group are treated as scroungers, while

the other individuals are handled as rangers

Since the scheduling problem is different from the

continuous function optimization problem, here

indi-viduals in GSO are designed as job permutations p

Besides, the problem considered here is a

multi-objective problem, so the mechanisms of producers,

scroungers, and rangers need to be newly designed

Population initialization

In each generation, the proposed MDGSO maintains a

population with size ps, which is denoted as PL = {L1,

L2, , Lps} To get an initial PL with good

perfor-mance, both the NEH and NEH_WPT24heuristics are

applied Specifically, we use the NEH heuristic to

con-struct a permutation pNEH for the makespan criterion

Then, the NEH_WPT heuristic is performed to

gener-ate a permutation pNEH WPT for the total flow time

cri-terion Note that the NEH-WPT was validated as an

effective heuristic for the total flow time criterion The

two solutions are added into PL, and the remaining

ps-2 initial individuals are generated randomly Such an

initial strategy is able to obtain an initial population

with both diversity and quality

The algorithm also maintains a set of non-dominated

solutions, which is denoted as NS = {S1, S2, , Snb},

where nb is the incumbent size of NS The set NS is an

independent set which stores the non-dominated

solu-tions found by the algorithm so far After the

initialization of PL, the NS is initialized by the non-dominated solutions of PL Besides, each solution in

PLis initially marked as ‘‘unsearched.’’ An example of

PL and NS is shown in Figure 2, where ps = 20 and

nb= 6

Producer procedure

The purpose of producers is to explore the neighbor-hood region of a relatively better solution For the multi-objective problem, the relatively better solutions are non-dominated solutions stored in NS So the pro-ducer is designed as follows:

Step 1.If there exists an ‘‘unsearched’’ solution Skin

NS, then let X = Sk, and go to Step 3

Step 2.Randomly select a solution Shfrom NS, and let X = Sh Apply d insert moves to X and perform

an insertion-based Pareto local search (IPLS) on X Step 3 Perform IPLS on X If X is not updated, mark the corresponding Skin NS with ‘‘searched.’’

In Step 1 of the above procedure, the solution Skis selected as follows: if there exists one and only one

‘‘unsearched’’ solution in NS, then the solution is assumed as Sk; if there exists more than one

‘‘unsearched’’ solutions in NS, then a randomly selected one among them is assumed as Sk

In Step 2 of the above procedure, the insert move means randomly selecting a job from the permutation and inserting it to another position of the permutation The IPLS searches the insert neighborhood of X in the way that X is updated if and only if a neighbor domi-nates X The searching process does not stop until a local optimum is found The steps of IPLS are as follows:

Figure 2 Solutions in population and non-dominated set.

Step 1 Randomly generate a permutation pr =

fpr1, pr2, , prng, and let i = 0 and j = 1

Step 2 Find the position of job prj in X, insert the

job into the other n 2 1 positions in X to obtain n 2 1

solutions, and find the local non-dominated solution

set (denoted as LNS here) of these n 2 1 solutions

Step 3.If there exists an X02 LNS and X0 X , then

let LNS = LNS\X#, X = X0, i = 1; else i = i + 1

Step 4 Let j = (j + 1) % n, update NS using LNS

and mark all the newly added solutions in NS as

‘‘unsearched.’’

Step 5.If i \ n, go to Step 2; else update NS using X

and mark all the newly added solutions in NS as

‘‘unsearched.’’

Note that the producer procedure is applied for one

time in each generation, and whenever a solution is

newly added in NS, the algorithm does not apply the

producing operation on it immediately, just marking it

as ‘‘unsearched.’’

Scrounger procedure

In each generation, all the individuals in the population

are either selected as scrounger (with probability p) or

ranger (with probability 1 2 p) In MDGSO, the scroun-ger is designed by introducing the crossover operator in genetic algorithm Specifically, we randomly select a solution in NS and apply partially mapped crossover to

it and the current scrounger individual Then, the cur-rent scrounger individual is updated according to the dominance relations of parent and offspring The steps

of scrounger procedure are as follows:

Step 1 Randomly select a solution (denoted by Sk)

in NS and perform partially mapped crossover

on Sk and the current scrounger individual (denoted by Li) Denote the obtained offspring as

X1and X2 Step 2 Update NS using X1 and X2 and mark all the newly added solutions in NS as ‘‘unsearched.’’ Step 3.If Li X1(A B means A dominates B) and

Li X2 (see Figure 3(a)), then Li remains unchanged; if Li X1 (or X2) but Lidoes not domi-nate X2(or X1) (see Figure 3(b)), then Liis replaced with X2(or X1); if Lidoes not dominate X1and Li does not dominate X2, then two cases exist: if X1(or

X2) dominates X2(or X1) (see Figure 3(c)), then Liis replaced with X1(or X2); else (see Figure 3(d)), Liis replaced with a randomly selected offspring

Figure 3 The dominance relation of offspring solutions (a) L i dominates both x 1 and x 2 , (b) L i dominates x 1 but not dominates x 2 , (c) Lidoes not dominates x1or x2while x1dominates x2, (d) Lidoes not dominates x1or x2while no domination relation exists

Ranger procedure

In GSO, ranger is designed to perform random search;

however, in the proposed MDGSO, the search

proce-dure of ranger is not completely random but based on

the solution set NS For a ranger Li, first a solution in

NSis randomly selected Then, the insert neighborhood

(denoted as Nb(X) for solution X) is searched and a

des-cend direction is selected The search process iterates

until the solution could not be improved in that descend

direction At the end of ranger procedure, the

incum-bent ranger individual Liis replaced by the final

solu-tion found by the search process The whole steps are as

follows:

Step 1.Randomly select a solution Skin NS, and let

X= Sk

Step 2 If there exists a solution X02 Nb(X ), and

f1(X0)\f1(X ), then go to Step 3; if there exists a

solution X02 Nb(X ), and f2(X0)\f2(X ), then go to

Step 4; else stop

Step 3 Nb(X) = Nb(X)\X#, update NS using Nb(X)

and mark all the newly added solutions in NS as

‘‘unsearched.’’ X = X0, if there exists a solution

X02 Nb(X ), and f1(X0)\f1(X ), then go to Step 3;

else go to Step 5

Step 4 Nb(X) = Nb(X)\X#, update NS using Nb(X)

and mark all the newly added solutions in NS as

‘‘unsearched.’’ X = X0, if there exists a solution

X02 Nb(X ), and f2(X0)\f2(X ), then go to Step 4;

else go to Step 5

Step 5.Update NS using X If X is newly added in

NS, denote it as ‘‘searched.’’ The incumbent ranger

individual Liis replaced by X

Procedure of MDGSO

In the proposed MDGSO, the iteration is executed

after the initial population PL and non-dominated

solution set NS is generated In each iteration, first the

producer procedure is performed, then for each

individ-ual in PL, either scrounger procedure (with probability

p) or ranger procedure (with probability 1 2 p) is

per-formed There are only three parameters, ps, d, and p,

to be determined in MDGSO, and the whole procedure

is illustrated in Figure 4

Computational experiments and results

To validate the effectiveness of the proposed MDGSO,

the well-known Taillard benchmark set which can be

downloaded from the OR library

(http://people.brune-l.ac.uk/;mastjjb/jeb/info.html) was used This article

tackled 90 instances, in which job number is from 20 to

100, and machine number is from 5 to 20 It should be

noted that all tested algorithms were programmed in

C++ language, and a PC with Window 7 operating

system, Intel(R) Core(TM) i7-2600 CPU @3.06 GHz and 4 GB RAM was used to execute the algorithms

Performance measures

There are various performance measures for multi-objective optimization to compare the performance of different algorithms We use the following two measures:

1 Inverted generational distance (IGD).25 Let P*

be a set of reference solutions and A be the non-dominated solution set found by an algorithm The generalized distance of point x and point

yis

d(x, y) =

ffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi

X2

i = 1

fi(x) fi(y)

fimax fmin i

v u

ð9Þ

where fi( ) is the ith objective value, and fmax

i , fmin

i are the maximum value and minimum value of the ith objective for P*

The IGD for A is computed as

IGD(A, P) = 1

P

j j

X y2P 

min x2A d(x, y) ð10Þ

Figure 4 The flow chart of MDGSO.

The IGD index reflects the average value of the

mini-mum distance of A and all solutions in P*

2 Set coverage.26 Let A and B are two

non-dominated solutions, the set coverage C(A, B)

represents the percentage of solutions in B that

are dominated by at least one solution in A,

computed as

C(A, B) =jfx 2 Bj9y 2 A : y  xgj

B

Computational results

In our computational experiments, the MDGSO was

applied to solve each of the 90 instances with 10

repli-cates Note that for each instance, we could obtain a

solution set for each run For convenience, all the

solu-tion sets of 10 replicates were gathered and a

non-dominated solution set A was obtained Two existing

powerful meta-heuristics, non-dominated sorting

genetic algorithm (NSGA-II)27 and bi-objective

multi-start simulated annealing algorithm (BMSA),28 were

adapted for the considered problem here for

compari-son For each instance, we obtained the non-dominated

solution set for each algorithm and then the

perfor-mance measures were computed Note that since the

Pareto front for each instance was not known, the

ref-erence solution set P*was formed by gathering all the

non-dominated solution sets for all tested algorithms

Regarding the parameter calibration for the MDGSO,

the bigger the population size ps, the better the results

are expected to be However, a bigger ps value will

inevitably cause more computational expense

Parameter d also affects the performance of the

pro-posed algorithm If it is too big, the solution obtained

by d insert moves in producer procedure will possibly

lose good characteristics of the original solution If it is

too small, the obtained solution will be possibly not

able to escape the original local optimum As for

para-meter p which determines the probability that an

indi-vidual is treated as scrounger, a relatively bigger value

is a better choice since the ranger usually uses lower

probability in GSO After some pilot experiments, we

found that when the parameters were set as ps = 15,

d =6, and p = 0.8, the algorithm achieved relatively

better performance Thus, in the computational

experi-ments, the above parameter setting was used for the

MDGSO while the parameters of the other two

algo-rithms were set as the original papers in the literature

The stopping criterion was set as 30mn ms

The statistical results are given in Tables 1 and 2,

showing IGD values and set coverage values,

respec-tively In the tables, the results are grouped by instance

size for convenience, and bold numbers denote the

bet-ter values

Table 1 The IGD values of the algorithms for instances grouped by different sizes.

IGD: inverted generational distance; MDGSO: multi-objective discrete group search optimizer; BMSA: bi-objective multi-start simulated annealing algorithm; NSGA: non-dominated sorting genetic algorithm.

Table 2 The set coverage values of the algorithms for instances grouped by different sizes.

BMSA (B)

MDGSO (A) vs NSGA-II (C)

MDGSO: multi-objective discrete group search optimizer; BMSA: bi-objective multi-start simulated annealing algorithm; NSGA:

non-dominated sorting genetic algorithm.

Figure 5 The non-dominated solutions obtained by the three algorithms for Ta36.

From Table 1, we can see that for the instances with

20 jobs, the differences between the MDGSO and the

other two algorithms are not significant, which is

prob-ably because of the simplicity of the small-size

instances However, for the instances with 50 and 100

jobs, the IGD values of the MDGSO are clearly greater

than the other two algorithms, which indicates the

superiority of the MDGSO We note that for some

groups, the IGD values of the MDGSO are nearly

zero, which means that the solution sets obtained by

the MDGSO are very close to the reference solution sets Table 1 also indicates the superiority of the BMSA over the NSGA-II

Table 2 shows the differences of the algorithms’ per-formances in another facet For the comparison between the MDGSO and the BMSA, the C(A, B) value is greater while the C(B, A) value is smaller, which indicates that the MDGSO is superior to the BMSA Similarly, the values in the other two columns validate the superiority of the MDGSO over the NSGA-II

To show the differences among the algorithms more clearly, we draw the non-dominated solution set of each algorithm for instance Ta36 and Ta86 in Figures 5 and 6, respectively Note that the non-dominated solu-tion set of each algorithm is formed by the results of 10 replicates It is seen from these two figures that the non-dominated solutions found by the MDGSO have better diversity as well as better quality than those found by any of the other algorithms As an example, the Gantt chart of a non-dominated solution for instance Ta01 is shown in Figure 7, where the makespan is 1380 and the total flow time is 15,042

Conclusion

This article has presented an MDGSO for the multi-objective optimization in blocking flow shop

Figure 6 The non-dominated solutions obtained by the three

algorithms for Ta86.

Figure 7 Gantt chart of a non-dominated solution for instance Ta01.

scheduling A population initialization method based

on NEH heuristic and its variants has been designed to

generate diversified solutions Besides, we have

designed the strategies of producers, scroungers, and

rangers by hybridizing some local search methods, and

we have conducted a multitude of experiments

mini-mizing both the makespan and total flow time

objec-tives in blocking flow shop scheduling The

computational results have shown that the proposed

algorithm is superior to both the NSGA and BMSA in

terms of IGD and set coverage In future, we will focus

on adapting the discrete GSO to other complex

sche-duling problems, such as the no-wait job shop problem,

the flexible flow shop problem, and stochastic

schedul-ing problem

Declaration of conflicting interests

The author(s) declared no potential conflicts of interest with

respect to the research, authorship, and/or publication of this

article.

Funding

The author(s) disclosed receipt of the following financial

sup-port for the research, authorship, and/or publication of this

article: The authors appreciate the support of National

Natural Science Foundation of China (Grant No 61403180),

the Project for Introducing Talents of Ludong University

(LY2013005), National Natural Science Foundation of China

(Grant No 51407088), and Promotive Research Fund for

Excellent Young and Middle-aged Scientists of Shandong

Province (Grant No BS2015DX018).

References

1 Garey MR, Johnson DS and Sethi R The complexity of

flowshop and jobshop scheduling Math Oper Res 1976;

1: 117–129.

2 Ruiz R and Stutzle T A simple and effective iterated

greedy algorithm for the permutation flowshop

schedul-ing problem Eur J Oper Res 2007; 177: 2033–2049.

3 Gao KZ Effective ensembles of heuristics for scheduling

flexible job shop problem with new job insertion Comput

Ind Eng 2015; 90: 107–117.

4 Gao KZ, Suganthan PN, Chua TJ, et al A two-stage

artificial bee colony algorithm scheduling flexible

job-shop scheduling problem with new job insertion Expert

Syst Appl 2015; 42: 7652–7663.

5 Gao KZ, Suganthan PN, Pan QK, et al An effective

dis-crete harmony search algorithm for flexible job shop

scheduling problem with fuzzy processing time Int J

Prod Res 2015; 53: 5896–5911.

6 Martinez S, Peres SD, Gueret C, et al Complexity of

flowshop scheduling problems with a new blocking

con-straint Eur J Oper Res 2006; 169: 855–864.

7 Gong H, Tang L and Duin CW A two-stage flow shop

scheduling problem on a batching machine and a discrete

machine with blocking and shared setup times Comput Oper Res 2010; 37: 960–969.

8 Hall NG and Sriskandarajah C A survey of machine scheduling problems with blocking and no-wait in pro-cess Oper Res 1996; 44: 510–525.

9 Companys R and Mateo M Different behaviour of a double branch-and-bound algorithm on Fm/prmu/Cmax and Fm/block/C max problems Comput Oper Res 2007; 34: 938–953.

10 Bautista J, Cano A, Companys R, et al Solving the Fm/ block/Cmax problem using bounded dynamic program-ming Eng Appl Artif Intel 2012; 25: 1235–1245.

11 McCormick ST, Pinedo ML, Shenker S, et al Sequencing

in an assembly line with blocking to minimize cycle time Oper Res 1989; 37: 925–936.

12 Leisten R Flowshop sequencing problems with limited buffer storage Int J Prod Res 1990; 28: 2085–2100.

13 Ronconi DP A note on constructive heuristics for the flowshop problem with blocking Int J Prod Econ 2004; 87: 39–48.

14 Caraffa V, Ianes S, Bagchi TP, et al Minimizing make-span in a blocking flowshop using genetic algorithms Int

J Prod Econ 2001; 70: 101–115.

15 Grabowski J and Pempera J The permutation flowshop problem with blocking: a tabu search approach Omega 2007; 35: 302–311.

16 Wang L, Pan QK, Suganthan PN, et al A novel hybrid discrete differential evolution algorithm for blocking flow shop scheduling problems Comput Oper Res 2010; 37: 509–520.

17 Ribas I, Companys R and Tort-Martorell X An iterated greedy algorithm for the flowshop scheduling problem with blocking Omega 2011; 39: 293–301.

18 Wang L, Pan QK and Tasgetiren MF A hybrid harmony search algorithm for the blocking permutation flow shop scheduling problem Comput Ind Eng 2011; 61: 76–83.

19 Deng G, Xu Z and Gu X A discrete artificial bee colony algorithm for minimizing the total flow time in the block-ing flow shop schedulblock-ing Chinese J Chem Eng 2012; 20: 1067–1073.

20 Gao KZ, Suganthan PN, Pan QK, et al Pareto-based grouping discrete harmony search algorithm for multi-objective flexible job shop scheduling Inform Sci 2014; 289: 76–90.

21 Gao KZ, Suganthan PN, Pan QK, et al Discrete har-mony search algorithm for flexible job shop scheduling problem with multiple objectives J Intell Manuf 2016; 27: 363–374.

22 Yenisey MM and Yagmahan B Multi-objective permuta-tion flow shop scheduling problem: literature review, clas-sification and current trends Omega 2014; 45: 119–135.

23 He S, Wu QH and Saunders JR A novel group search optimizer inspired by animal behavioral ecology In: IEEE international conference on evolutionary computa-tion (CEC’2006), Vancouver, BC, Canada, 16–21 July

2006, pp.1272–1278 New York: IEEE.

24 Wang L, Pan QK and Tasgetiren MF Minimizing the total flow time in a flow shop with blocking by using hybrid harmony search algorithms Expert Syst Appl 2010; 37: 7929–7936.

25 Coello C and Corte´s N Solving multiobjective

optimiza-tion problems using an artificial immune system Genet

Program Evol M 2005; 6: 163–190.

26 Zitzler E, Deb K and Thiele L Comparison of

multiob-jective evolutionary algorithms: empirical results Evol

Comput 2000; 8: 173–195.

27 Deb K, Pratap A, Agarwal S, et al A fast and elitist mul-tiobjective genetic algorithm: NSGA-II IEEE T Evolut Comput 2002; 6: 182–197.

28 Lin SW and Ying KC Minimizing makespan and total flowtime in permutation flowshops by a bi-objective multi-start simulated-annealing algorithm Comput Oper Res 2013; 40: 1625–1647.