This paper investigates the permutation flowshop scheduling problem (PFSP) with the objectives of minimizing the makespan and the total flowtime and proposes a hybrid metaheuristic based on the particle swarm optimization (PSO). To enhance the exploration ability of the hybrid metaheuristic, a simulated annealing hybrid with a stochastic variable neighborhood search is incorporated. To improve the search diversification of the hybrid metaheuristic, a solution replacement strategy based on the pathrelinking is presented to replace the particles that have been trapped in local optimum. Computational results on benchmark instances show that the proposed PSO-based hybrid metaheuristic is competitive with other powerful metaheuristics in the literature.
1. Introduction
Due to the strong industrial background, the permutation flowshop scheduling problem (PFSP) has attracted considerable attention from researchers all over the world. In this problem, a set of jobs J={1,2,…,n} needs to be processed through a set of machines M={1,2,…,m}. Each job i∈J should be processed through these m machines with the same machine order, that is, starting from machine 1 and finishing on the last machine m. The processing time of each job i∈J on machine j∈M(pij) is nonnegative and known before scheduling. It is assumed that all the jobs are available before processing and once started the processing cannot be interrupted. It is required that each job can only be processed by only one machine at any time, and at the same time each machine cannot process more than one job. The processing of a job cannot start on the next machine j+1 until this job has been completed on the current machine j and machine j+1 is idle. The objective is to determine the sequence of these n jobs so that a certain performance measure can be optimized. The most commonly studied performance measures are the minimization of makespan (Cmax) and the minimization of total flowtime (TFT). Let π=(π(1),…,π(n)) denote a permutation of the n jobs, in which π(k) represents the job arranged at the kth position, and the completion time of each job π(k) on each machine j can be calculated as follows:
(1)Cπ(1),1=pπ(1),1,Cπ(1),j=Cπ(1),j-1+pπ(1),j,j=2,3,…,m,Cπ(k),1=Cπ(k-1),1+pπ(k),1,k=2,3,…,n,Cπ(k),j=max{Cπ(k),j-1,Cπ(k-1),j}+pπ(k),j,k=2,3k=k=2,3,…,n;j=2,3,…,m.
Then the makespan can be defined as Cmax(π)=Cπ(n),m, and the total flowtime can be defined as the sum of completion times of all jobs TFT(π)=∑k=1nCπ(k),m.
Since the first introduction of the PFSP [1], considerable attention of researchers has been paid to this problem and many kinds of algorithms have been proposed in the literature. According to the comprehensive review of Ruiz and Maroto [2] and Framinan et al. [3] for PFSP, these solution methods can be classified into three categories: exact methods, heuristics methods, and metaheuristic methods.
Since it has been proven that the PFSP with makespan minimization is NP-complete in the strong sense when m≥3 and the PFSP with total flowtime minimization is NP-complete in the strong sense when m≥2 [4], few exact methods have been proposed for PFSP in the literature due to their unacceptable computation time. These exact methods include the mixed integer linear programming method [5] and the branch and bound algorithms ([6–8] for the makespan minimization and [9–11] for the total flowtime minimization). However, these exact methods are feasible for only small size problems because they cannot solve large size problems in reasonable computation time.
Heuristic methods can be classified into two categories: constructive heuristics and improvement heuristics. Constructive methods start from an empty solution and try to build a feasible solution in a short time. Johnson’s algorithm [1] is the earliest known heuristic for PFSP, which can obtain optimal solutions for m=2. Campbell et al. [12] proposed the CDS heuristic, and Koulamas [13] proposed a two-phase heuristic for PFSP, which were both extensions of Johnson’s algorithm. Palmer [14] proposed a slope index heuristic for PFSP, and then Gupta [15] and Hundal and Rajgopal [16] extended Palmer’s heuristic and proposed two simple heuristics. Nawaz et al. [17] proposed a so-called NEH heuristic based on the idea that jobs with high total processing times on all machines should be scheduled as early as possible, and this NEH heuristic is regarded as the best heuristic for PFSP with makespan minimization (Ruiz and Maroto [2], Taillard [18]). Recently, complex heuristics have been proposed for PFSP, for example, Liu and Reeves [19] and Framinan and Leisten [20]. As far as the solution quality is concerned, the FL heuristic proposed by Framinan and Leisten [20] was the best one among simple heuristics (Framinan et al. [3]). Contrary to constructive heuristics, improvement heuristics start from an existing initial solution and try to improve it by a given procedure, for example, a local search. Fan and Winley [21] proposed a heuristic named the intelligent heuristic search algorithm for the PFSP. Suliman [22] proposed a two-phase improvement heuristic, in which an initial solution is generated by the CDS heuristic in the first phase and then improved by a pair exchange neighborhood search in the second phase. Framinan et al. [23] proposed a new efficient heuristic for the PFSP with no-wait constraint.
Metaheuristics are high-level strategies that combine and guide other heuristics in the hope of obtaining a more efficient or more robust procedure so that better solutions can be found. The main procedure of metaheuristics generally starts from an initial solution or a set of solutions generated by heuristics and iterates to improve the initial solution or solutions until a given stopping criterion is reached. The metaheuristics proposed for PFSP are mainly the genetic algorithm (Chang et al. [24], Ruiz et al. [25]), the simulated annealing (Hooda and Dhingra [26], Nouri et al. [27]), the tabu search (Gao et al. [28]), the ant colony algorithm (Rajendran and Ziegler [29]), the iterated greedy algorithm (Ruiz and Stützle [30]), and the particle swarm optimization (PSO) (Tasgetiren et al. [31], Wang and Tang [32]). These metaheuristics use the benchmark problems proposed by Taillard [33] to evaluate their performance. The ant colony algorithms proposed by Rajendran and Ziegler [29], named M-MMAS and PACO, obtained much better solutions than constructive heuristics of Framinan and Leisten [20]. The iterated greedy algorithm proposed by Ruiz and Stützle [30] improved the best known results for some instances of PFSP with makespan minimization. The particle swarm optimization (PSO) named PSOVNS, which incorporates variable neighborhood search (VNS) into PSO, proposed by Tasgetiren et al. [31] improved 57 out of 90 best known solutions reported by Framinan and Leisten [20] and Rajendran and Ziegler [29] for the total flowtime criterion.
In this paper, we propose an improved PSO for the PFSP. To enhance the exploration ability of PSO, the path relinking and the hybrid simulated annealing with stochastic VNS are incorporated. To improve the search diversification of PSO, a population update method is applied to replace the nonpromising particles. The rest of this paper is organized as follows. Section 2 is devoted to describe the proposed PSO algorithm. The computational results on benchmark problems are presented in Section 3. Finally, Section 4 concludes the paper.
2. PSO Algorithm for PFSP2.1. Brief Introduction of PSO
PSO algorithm is a population based metaheuristic method introduced by Kennedy and Eberhart [34, 35] based on the social behavior of bird flocking and fish schooling, as well as the means of information exchange between individuals, to solve optimization problems. In the PSO, a swarm consists of m particles and these particles fly around in an n-dimensional search space. The solution of a problem is represented by the position of a particle; that is, the ith particle at the tth generation is denoted as Xit=[xi1t,xi2t,…,xint]. At each generation, the flight of each particle is determined by three factors: the inertia of itself, the best position found by itself (pbest), and the best position found by the whole swarm (gbest). Generally, pbest and gbest are represented as Pit=[pi1t,pi2t,…,pint] and Gt=[g1t,g2t,…,gnt], respectively. Then the velocity of the particle Vit=[vi1t,vi2t,…,vint] for the next generation can be obtained from the following equation:
(2)vijt+1=w·vijt+c1r1·(pijt-xijt)+c2r2·(gjt-xijt),xijt+1=xijt+vijt+1,
where w is called the inertia parameter, c1 and c2 are the cognitive and social parameters, and r1, r2 are random numbers between (0,1). Based on the above equations, the particle can fly through search space toward pbest and gbest in a navigated way while still exploring new areas by the stochastic mechanism to escape from local optima.
2.2. Solution Representation
Since the PSO operates in the continuous space, a job is represented by a dimension of a particle and then the n jobs can be denoted as a particle Xit=[xi1t,xi2t,…,xint] in the continuous space. Due to the continuous characters of the position values of particles in the PSO, the smallest position value (SPV) rule proposed by Tasgetiren et al. [31] is adopted to transform a particle with continuous position values into a job permutation. A simple example is provided in Table 1 to show the mechanism of the SPV rule. In this instance (n=9), the smallest position value is xi2t=-1.75, so job 2 is assigned to the first position of the job permutation according to the SPV rule; then job 9 is assigned to the second position of the job permutation because it has the second smallest position value xi9t=-1.21. With the same way, other jobs are assigned in their corresponding position of the job permutation according to their position values. Thus, based on the SPV rule, the job permutation is obtained; that is, πit=(2,9,4,3,5,1,8,7,6).
Solution representation and the corresponding job permutation using SPV rule.
Dimension j
1
2
3
4
5
6
7
8
9
xijt
0.35
−1.75
−0.02
−0.21
0.02
1.20
1.03
0.67
−1.21
Job, πijt
6
1
4
3
5
9
8
7
2
2.3. Population Initialization
The population with npop solutions is initialized with random solutions according to xij0=xmin+rand×(xmax-xmin), where rand is a uniform random number in [0,1], xmin=-4.0, and xmax=4.0. Also, we generate the corresponding velocity of each particle by a similar way: vij0=vmin+rand×(vmax-vmin), where vmin=-1.0 and vmax=1.0. In addition, another solution generated by the NEH heuristic [18] is added to the initial population and replaces a random selected solution so as to ensure the quality of initial population.
2.4. Hybrid Method of Simulated Annealing and Stochastic VNS
In the PSOVNS proposed by Tasgetiren et al. [31], a stochastic VNS, which itself is a variant of VNS (Hansen and Mladenović [36]), is developed as the local search. For a given discrete job permutation πt, let w and z denote two different random integer numbers generated in [1,n], and then the two stochastic neighborhoods moves used in the stochastic VNS to generate a neighbor solution πt′ are (1)πt′=insert(πt,w,z): remove the job at the wth position and insert it in the zth position; and (2)πt′=interchange(πt,w,z): interchange two jobs arranged at the wth position and the zth position. After a job permutation is changed according to a local search operator such as insert or interchange, the position value of each dimension is adjusted correspondingly to guarantee that the permutation that resulted by the SPV rule for new position values is the same as the permutation that resulted by the local search operator. For example, Table 2 shows the interchange move applied to two jobs 3 and 7, and the corresponding position value changes. It is clear that the interchange of jobs 3 and 7 is corresponding to the interchange of position values −1.02 and 0.23. The position value adjustment for the insert move is similar.
Interchange move on the job permutation and the corresponding position value adjustment.
Dimension j
1
2
3
4
5
6
7
8
Before interchange
xijt
0.54
−0.75
−1.02
−0.41
0.92
−1.20
0.23
0.12
Job, πijt
6
3
2
4
8
7
1
5
After interchange
xijt
0.54
−0.75
0.23
−0.41
0.92
–1.20
−1.02
0.12
Job, πijt
6
7
2
4
8
3
1
5
The bold and italic values are used to show the interchange move applied to jobs 3 and 7.
To further improve the exploration ability of the local search, we incorporate the solution acceptance scheme of simulated annealing into the stochastic VNS and thus obtain a hybrid method of simulated annealing and stochastic VNS (denoted as SA_VNS). To reduce the computation time and make the search process focus on the intensification phase, we use a decreasing acceptance threshold to act as the cooling procedure of simulated annealing. The procedure of the proposed SA_VNS algorithm is illustrated in Algorithm 1.
Algorithm 1: The main procedure of the SA_VNS.
Begin:
Initialization:
Let π0 be the input initial solution. Set π=π0, the acceptance threshold T=0.05, and
outerloop_counter=0.
while (outerloop_counter<n/5) do
(1) Generate a random number r in [0, 1], and two random integer numbers w and z.
If r > 0.5, generate π′ = insert (π,w,z); otherwise generate π′ = interchange (π,w,z).
(2) Set inner_counter=0.
(3) while(inner_counter<n×(n-1))do
Set k=1.
while (k≤2) do
(1) Generate two random integer numbers w and z.
(2) If k=1, generate π′′ = insert(π′,w,z).
(3) If k=2, generate π′′ = interchange(π′,w,z).
(4) If f(π′′)<f(π′),then setπ′=π′′ and k=1; otherwise set k=k+1.
end while
Set inner_counter=inner_counter+1.
end while
(4) If f(π′)<f(π0),setπ0=π′andπ=π′, and then go to step 6; otherwise go to step 5.
(5) If f(π′)≥f(π0)but(f(π′)-f(π0))/f(π0)≤T,setπ=π′; otherwise, generate a random
number r in [0, 1], and then set π=π0 if r>0.5 and π=π′ if r≤0.5.
(6) Set T=T×0.95 and outerloop_counter=outerloop_counter+1.
end while
Report the improved solutionπ0.
End
In the PSOVNS proposed by Tasgetiren et al. [31], the stochastic VNS is applied on the global best particle found at each iteration. However, a drawback of such application is that the starting point of the stochastic VNS may be the same solution if the global best particle cannot be improved for a number of consecutive iterations, and consequently the exploration ability of the PSO may be decreased. Therefore, for a given population at iteration t, we propose to use the following strategy.
Step 1.
Apply the SA_VNS on the promising particles satisfying (f(πt)-f(gbest))/f(gbest)≤0.02, in which f(πt) is the objective value of particle πt.
Step 2.
Update the global best particle. If a new global best particle is found, then further improve it using the SA_VNS.
2.5. Population Update Method
It is well known that the advantage of PSO is that it has a high convergence speed. However, this advantage may become the disadvantage for complex scheduling problems because the scheduling problems generally have many local optimal regions in the search space. That is, for the PSO applied to PFSP, some particles may always fly around a local region and thus are trapped in local optimum. Therefore, we propose a solution replacement strategy based on the pathrelinking [37] to remove these solutions with new solutions with good quality.
In our algorithm, a particle is viewed as being trapped in local optimum if its personal best solution pbest has not been improved for a number of consecutive generations (i.e., 20). For these particles, we give them the last chance to stay in the population by applying the path relinking algorithm on it to check if its personal best pbest can be improved. If so, this particle can remain in the population; otherwise, we replace this particle with a new random particle.
The path relinking is originally proposed by Glover et al. [37] to generate new solutions by exploring a path that connects an initial solution and a guiding solution. In this path, moves are selected that introduce attributes contained in the guiding solution. To present the path relinking algorithm, we define the distance between two particles Xi and Xj as d(Xi,Xj)=d(πi,πj)=|h(πi)-h(πj)|, where π is the corresponding job permutation (obtained by the SPV rule) of particle X and h(π) is the Hash function value of π=(π(1),…,π(n)) that is calculated as h(π)=∑k=1nk×π(k)×π(k). Then the path relinking algorithm can be described as follows.
Step 1.
Set πi=(πi(1),πi(2),…,πi(n)) as the initial solution. Find the particle that has the largest distance to particle Xi in the current population (denoted as Xj), and set its corresponding job permutation πj=(πj(1),πj(2),…,πj(n)) as the guiding solution. Set k=1 and the local optimum πopt=πi.
Step 2.
If πi(k)≠πj(k), find the job with index πj(k) in πi and swap it with πi(k) to generate a new job permutation πi′. If πi′ is better than πopt, then set πopt=πi′.
Step 3.
Set k=k+1. If k>n-10, stop; otherwise, go to Step 2.
It should be noted that the above path relinking stops when k is larger than n-10, because if particle Xj is better than Xi, then Xi will be replaced by Xj if the path relinking stops when k=n, which may result in duplicated particles and thus decrease the search diversification.
2.6. Complete Procedure of the Proposed PSOStep 1.
Initialization
Step 1.1. Set initial values for the population size npop, the inertia weight, and the cognitive and social parameters. Set t=0 and NOi=0(i=1,2,…,npop) for each particle in the population. Create the initial population and the initial velocities for each particle using the method described in Section 2.3.
Step 1.2. Generate the job permutation for each particle in the population using the SPV rule, and calculate the objective value of each particle.
Step 1.3. Set the personal best of each particle to be the particle itself and the global best to be the best one among the population.
Step 2.
Update Particle Positions
Step 2.1. Update iteration counter t=t+1.
Step 2.2. Update inertia weight by w=w×β.
Step 2.3. For each particle, update the velocity and position values according to (2).
Step 2.4. Generate the job permutation for each particle in the current population using the SPV rule, and calculate the objective value of each particle.
Step 3.
Local Search Phase
Step 3.1. Use the SA_VNS algorithm to improve the promising particles in the current population and then the global best particle found so far according to the adoption strategy of SA_VNS described in Section 2.4.
Step 3.2. For each particle in the current population, update its personal best pbest. If pbest of particle i is improved, then set NOi=0; otherwise set NOi=NOi+1.
Step 4.
Population Update. For each particle in the current population, use the population update method described in Section 2.5 to update the current population.
Step 5.
Stopping Criterion. If t>Tmax (the maximum iteration number) or the runtime has reached the limit, then stop; otherwise, go to Step 2.
3. Computational Experiments
To test the performance of our PSO algorithm (denoted as PSO*), computational experiments were carried out on the well-known standard benchmark set of Taillard [33] that is composed of 110 instances ranging from 20 jobs and 5 machines to 200 jobs and 20 machines. This benchmark set contains some instances proven to be very difficult to solve. In this benchmark set there are 10 instances for each problem size. Our PSO algorithm was implemented using C++ and tested on a personal PC with Pentium IV 3.0 GHz CPU and 512 MB memory. To make a fair comparison with the PSOVNS, we use the same parameter setting proposed by Tasgetiren et al. [31]. That is, the population size is taken as npop=2n; the initial inertia weight is set to w=0.9 and never less than 0.4; the decrement factor β for w is taken as 0.975; the acceleration coefficients are set to c1=c2=2; the maximum iteration number Tmax is taken as 500.
3.1. Results for PFSP with Makespan Minimization
For the makespan minimization objective, our PSO algorithm was compared with other powerful methods, for example, the ant colony algorithm named PACO of Rajendran and Ziegler [29], the genetic algorithm named HGA_RMA of Ruiz et al. [25], the iterated greedy algorithm named IG_RSLS of Ruiz and Stützle [30], and the PSOVNS algorithm of Tasgetiren et al. [31]. The solution quality was measured by the average relative percent deviation (denoted as ARPD) over R replicated runs for each instance in makespan with respect to the best known upper bounds. More specifically, ARPD is calculated as ARPD=∑i=1R(((Hi-Ui)×100)/Ui)/R, in which Hi is the makespan obtained by a certain algorithm, whereas Ui is the best known upper bound value for Taillard’s instances as of April 2004 for the makespan criterion. As done by many researchers, R is set to R=10 in our experiments.
The comparison results for these algorithms are given in Table 3, in which the values are the average performance of the 10 instances for each problem size. As seen in Table 3, our PSO* algorithm achieves the best average performance and it obtains the best results for instances of 20×5, 20×10, 50×5, 50×10, 100×5, 100×20, and 200×20. The IG_RSLS method also performs well with the HGA_RMA method being close. More specifically, the PACO method cannot obtain the lowest ARPD for any group of problem size compared to other rival methods. The HGA_RMA method has the lowest ARPD for instances of 20×10, 50×5, and 100×10. The IG_RSLS method demonstrates the best results for instances of 20×20, 50×5, 50×10, 50×20, and 200×10. For instances of 20×10, both the HGA_RMA method and the PSOVNS method give the best performance. For instances of 50×5, all the four methods except for PACO can obtain the lowest ARPD. For instances of 100×5, only the two PSO algorithms give the best performance. Our PSO* algorithm performs better than its rivals in 100×20 and 200×20 instances, which have been proven more difficult to solve. Therefore, it can be concluded that our PSO* algorithm is competitive with other powerful methods in the literature.
ARPD comparison of different methods for makespan criterion.
Problem
PACO
HGA_RMA
IG_RSLS
PSOVNS
PSO*
20×5
0.18
0.04
0.04
0.03
0.00
20×10
0.24
0.02
0.06
0.02
0.02
20×20
0.18
0.05
0.03
0.05
0.05
50×5
0.05
0.00
0.00
0.00
0.00
50×10
0.81
0.72
0.56
0.57
0.56
50×20
1.41
0.99
0.94
1.36
0.99
100×5
0.02
0.01
0.01
0.00
0.00
100×10
0.29
0.16
0.20
0.18
0.20
100×20
1.93
1.30
1.30
1.45
1.18
200×10
0.23
0.14
0.12
0.18
0.18
200×20
1.82
1.26
1.26
1.35
1.16
Average
0.65
0.43
0.41
0.47
0.39
The bold font is used to highlight the better solutions.
*used to denote our algorithm.
3.2. Results for PFSP with Total Flowtime Minimization
For the total flowtime minimization objective, our PSO algorithm was compared with other powerful methods, for example, the constructive heuristics of Framinan and Leisten [20], the ant colony algorithm of Rajendran and Ziegler [29], and the PSOVNS of Tasgetiren et al. [31], using the benchmark problems of Taillard [33]. The solution quality was measured by the relative percent deviation (denoted as RPD) of the best solution found among R(R=5) replicated runs for each instance in the total flowtime criterion with respect to the best known results. That is, RPD is calculated as RPD=min{((Hi-Ui)×100)/Ui,i∈R}, in which Hi is the total flowtime value obtained by a certain algorithm, whereas Ui is the best result obtained among the algorithms of Framinan and Leisten [20] and Rajendran and Ziegler [29] (this best result is denoted as LR and RZ).
For the minimization of the total flowtime criterion, the PSOVNS algorithm [31] is demonstrated to be a very powerful PSO algorithm because it improved 57 out of 90 best known solutions reported in [20, 29]. The comparison results between our PSO* and the PSOVNS are given in Table 4. From this table, we can see that the PSOVNS algorithm can obtain the best results for instances of 20×5, 20×10, 50×5, 100×5, and 100×10, while our PSO* algorithm obtains the best results for the other large size instances of 20×20, 50×10, 50×20, and 100×20. On average, our PSO* shows a much better performance in the solution quality and robustness than the PSOVNS algorithm.
Performance comparison of PSOVNS and PSO* for total flowtime criterion.
Problem
PSOVNS
PSO*
RPD
CPU (s)
RPD
CPU (s)
20×5
−0.175
3.18
−0.168
8.11
20×10
−0.037
7.21
−0.035
4.86
20×20
2.758
11.93
−0.068
24.97
50×5
−0.603
41.71
−0.531
40.28
50×10
−0.819
74.49
−0.892
44.32
50×20
0.857
143.32
−0.543
50.67
100×5
−0.570
222.28
−0.546
409.75
100×10
−0.692
407.88
−0.636
414.14
100×20
−0.104
824.41
−0.801
442.37
Average
0.068
192.93
−0.469
159.941
The bold font is used to highlight the better solutions.
*used to denote our algorithm.
4. Conclusions
This paper presents a PSO-based hybrid metaheuristic for the permutation flowshop problems to minimize the makespan and the total flowtime. In this algorithm, a hybrid method of simulated annealing and stochastic variable neighborhood search is incorporated to improve the exploitation ability, and a solution replacement strategy based on the path relinking method is developed to improve the exploration ability. Computational experiments are carried out to test the performance of the proposed PSO-based hybrid metaheuristic, and the results show that the proposed algorithm is competitive or superior to some other powerful algorithms in the literature for this problem. Future research may lie in the application of this algorithm in practical production scheduling problems.
Conflict of Interests
The authors declare that there is no conflict of interests regarding the publication of this paper.
Acknowledgments
This work is supported by National Nature Science Foundation under Grant 61004039, by the Science Foundation of Educational Department of Liaoning Province under Grant L2010374, and also by the Key Laboratory for Manufacturing Industrial Integrated Automation of Liaoning Province. The authors would like to thank the Associate Professor Hong Yang for her valuable comments.
JohnsonS. M.Optimal two- and three-stage production schedules with setup times included195411616810.1002/nav.3800010110RuizR.MarotoC.A comprehensive review and evaluation of permutation flowshop heuristics200516524794942-s2.0-1344425113410.1016/j.ejor.2004.04.017FraminanJ. M.LeistenR.Ruiz-UsanoR.Comparison of heuristics for flowtime minimisation in permutation flowshops2005325123712542-s2.0-754424341210.1016/j.cor.2003.11.002GareyM. R.JohnsonD. S.SethiR.The complexity of flowshop and jobshop scheduling1976121171292-s2.0-0016952078StaffordE. F.On the development of a mixed integer linear programming model for the flowshop sequencing problem19883911631174LomnickiZ. A.A branch and bound algorithm for the exact solution of the three machine scheduling problem19651689100BrownA. P. G.LomnickiZ. A.Some applications of the branch and bound algorithm to the machine scheduling problem196617173186McMahonG. B.BurtonP. G.Flowshop scheduling with the branch and bound method196715347348110.1287/opre.15.3.473IgnallE.SchrageL.Application of the branch and bound technique to some flow-shop scheduling problems196513340041210.1287/opre.13.3.400BansalS. P.Minimizing the sum of completion times of n jobs over m machines in a flowshop—a branch and bound approach19779330631110.1080/05695557708975160ChungC.-S.FlynnJ.KircaO.A branch and bound algorithm to minimize the total flow time for m-machine permutation flowshop problems20027931851962-s2.0-003706376910.1016/S0925-5273(02)00234-7CampbellH. G.DudekR. A.SmithM. L.A heuristic algorithm for the n job, m machine sequencing problem197016106306372-s2.0-0014807274KoulamasC.A new constructive heuristic for the flowshop scheduling problem1998105166712-s2.0-0032000804PalmerD.Sequencing jobs through a multi-stage process in the minimum total time—a quick method of obtaining a near optimum1965161101107GuptaJ. N. D.Heuristic algorithms for multistage flowshop scheduling problem19724111182-s2.0-0015316023HundalT. S.RajgopalJ.An extension of Palmer’s heuristic for the flow shop scheduling problem1988266111911242-s2.0-0024031629NawazM.EnscoreE. E.Jr.HamI.A heuristic algorithm for the m-machine, n-job flow-shop sequencing problem198311191952-s2.0-002069992110.1016/0305-0483(83)90088-9TaillardE.Some efficient heuristic methods for the flow shop sequencing problem199047165742-s2.0-0025700701LiuJ.ReevesC. R.Constructive and composite heuristic solutions to the P//∑Ci scheduling problem200113224394522-s2.0-003589898510.1016/S0377-2217(00)00137-5FraminanJ. M.LeistenR.An efficient constructive heuristic for flowtime minimisation in permutation flow shops20033143113172-s2.0-003797113110.1016/S0305-0483(03)00047-1FanJ. P.-O.WinleyG. K.A heuristic search algorithm for flow-shop scheduling20083244534642-s2.0-57349154329SulimanS. M. A.Two-phase heuristic approach to the permutation flow-shop scheduling problem20006411431522-s2.0-003390822310.1016/S0925-5273(99)00053-5FraminanJ. M.NaganoM. S.MoccellinJ. V.An efficient heuristic for total flowtime minimisation in no-wait flowshops2010469–12104910572-s2.0-7734909946410.1007/s00170-009-2154-0ChangP. C.HuangW. H.WuJ. L.A block mining and re-combination enhanced genetic algorithm for the permutation flowshop scheduling problem20131411455510.1016/j.ijpe.2012.06.007RuizR.MarotoC.AlcarazJ.Two new robust genetic algorithms for the flowshop scheduling problem20063454614762-s2.0-3004444984110.1016/j.omega.2004.12.006HoodaN.DhingraA. K.Flow shop scheduling using simulated annealing: a review201121234249NouriB. V.FattahiP.RamezanianR.Hybrid firefly-simulated annealing algorithm for the flow shop problem with learning effects and flexible maintenance activities201351123501351510.1080/00207543.2012.750771GaoJ.ChenR.DengW.An efficient tabu search algorithm for the distributed permutation flowshop scheduling problem201351364165110.1080/00207543.2011.644819RajendranC.ZieglerH.Ant-colony algorithms for permutation flowshop scheduling to minimize makespan/total flowtime of jobs200415524264382-s2.0-164255963310.1016/S0377-2217(02)00908-6RuizR.StützleT.A simple and effective iterated greedy algorithm for the permutation flowshop scheduling problem20071773203320492-s2.0-3375084108410.1016/j.ejor.2005.12.009TasgetirenM. F.LiangY.-C.SevkliM.GencyilmazG.A particle swarm optimization algorithm for makespan and total flowtime minimization in the permutation flowshop sequencing problem20071773193019472-s2.0-3375123681010.1016/j.ejor.2005.12.024WangX.TangL.A discrete particle swarm optimization algorithm with self-adaptive diversity control for the permutation flowshop problem with blocking20121226526622-s2.0-8465517674610.1016/j.asoc.2011.09.021TaillardE.Benchmarks for basic scheduling problems19936422782852-s2.0-0027201278KennedyJ.EberhartR.Particle swarm optimizationProceedings of the IEEE International Conference on Neural NetworksDecember 1995194219482-s2.0-0029535737EberhartR.KennedyJ.New optimizer using particle swarm theoryProceedings of the 6th International Symposium on Micro Machine and Human ScienceOctober 199539432-s2.0-0029517385HansenP.MladenovićN.Variable neighborhood search: principles and applications200113034494672-s2.0-003481808710.1016/S0377-2217(00)00100-4GloverF.LagunaM.MartíR.Fundamentals of scatter search and path relinking20002936526842-s2.0-0347899800