Next Article in Journal
Engineering a Combinatorial Laplacian Solver: Lessons Learned
Next Article in Special Issue
A Modified Cloud Particles Differential Evolution Algorithm for Real-Parameter Optimization
Previous Article in Journal
Plant Electrical Signal Classification Based on Waveform Similarity
Previous Article in Special Issue
A New Fuzzy Harmony Search Algorithm Using Fuzzy Logic for Dynamic Parameter Adaptation

Algorithms 2016, 9(4), 71; https://doi.org/10.3390/a9040071

Article
A Variable Block Insertion Heuristic for the Blocking Flowshop Scheduling Problem with Total Flowtime Criterion
by 3 and
1
International Logistics Management Department, Yasar University, Izmir 35100, Turkey
2
Department of Industrial and Manufacturing System Engineering, School of Mechanical Science and Engineering, Huazhong University of Science and Technology, Wuhan 430074, China
3
Industrial Engineering Department, Yasar University, Izmir 35100, Turkey
4
School of Electrical and Electronics, Nanyang Technological University, Singapore 639798, Singapore
*
Author to whom correspondence should be addressed.
Academic Editor: Javier Del Ser Lorente
Received: 30 June 2016 / Accepted: 8 October 2016 / Published: 20 October 2016

## Abstract

:
In this paper, we present a variable block insertion heuristic (VBIH) algorithm to solve the blocking flowshop scheduling problem with the total flowtime criterion. In the VBIH algorithm, we define a minimum and a maximum block size. After constructing the initial sequence, the VBIH algorithm starts with a minimum block size being equal to one. It removes the block from the current sequence and inserts it into the partial sequence sequentially with a predetermined move size. The sequence, which is obtained after several block moves, goes under a variable local search (VLS), which is based on traditional insertion and swap neighborhood structures. If the new sequence obtained after the VLS local search is better than the current sequence, it replaces the current sequence. As long as it improves, it keeps the same block size. However, if it does not improve, the block size is incremented by one and a simulated annealing-type of acceptance criterion is used to accept the current sequence. This process is repeated until the block size reaches at the maximum block size. Furthermore, we present a novel constructive heuristic, which is based on the profile fitting heuristic from the literature. The proposed constructive heuristic is able to further improve the best known solutions for some larger instances in a few seconds. Parameters of the constructive heuristic and the VBIH algorithm are determined through a design of experiment approach. Extensive computational results on the Taillard’s well-known benchmark suite show that the proposed VBIH algorithm outperforms the discrete artificial bee colony algorithm, which is one of the most efficient algorithms recently in the literature. Ultimately, 52 out of the 150 best known solutions are further improved with substantial margins.
Keywords:
meta-heuristics; blocking flowshop; block insertion heuristic; variable local search; constructive heuristics

## 1. Introduction

There have been extensive studies about permutation flowshop scheduling (PFSP) in the literature with many important applications in manufacturing and service systems [1,2,3,4]. The traditional PFSP is concerned with scheduling $n$ jobs through $m$ machines in such a way that the same sequence is applied to each machine. An important assumption is such that work-in-process inventory is allowed since there are infinite buffer capacities amongst consecutive machines. Hence, allowing jobs to be waiting in front of machines for their next operations words. On the other hand, if any storage capacity amongst machines is not available, the traditional PFSP is said to be blocking flowshop scheduling problem (BFSF) . In this case, a job cannot leave the machine unless the next machine is free. Its industrial applications can be found in [5,6]. A comprehensive review on flowshop scheduling with blocking and no-wait constraint can be found in Hall and Siriskandarajah .
The makespan criterion for the BFSP is commonly used in the literature. This problem is also denoted as $F m / b l o c k i n g / C m a x$ with the notation of Graham et al.  in the literature. Although Gilmore–Gomory’s algorithm  can solve it optimally with two machine case ($m = 2 ) ,$ it is proven to be NP-Hard by Hall and Sriskandarajah  when $m > 2$. For this reason, efforts have been devoted on developing heuristic and meta-heuristic approaches for scheduling a large number of jobs, which is commonly needed for real-life problems.
Since the problem is NP-Hard, constructive heuristics and meta-heuristic algorithms have been attracted attention to solve the BFSP with the makespan criterion. Regarding the constructive heuristics, McCormick et al.  presented a profile fitting (PF) heuristic to solve BFSP with the performance measure of minimization of cycle time. The PF heuristic greedily establishes a sequence with the next job having minimum idle and blocking times on machines. Leisten  presented a similar heuristic for flowshop scheduling problems with finite and unlimited buffers in order to maximize the buffer usages and to minimize the machine blocking times. However, it was not able to obtain better results than the NEH heuristic, which is initially proposed in  to solve the traditional PFSP. Depending on the makespan properties defined by Ronconi and Armentano , Ronconi  presented a note on constructive heuristics and proposed three constructive heuristics, called MM, MM combined with NEH (MME), and PF combined with NEH (PFE), respectively for the BFSP with the makespan criterion. It was shown that the MME and PFE heuristics generated better results than the NEH heuristics up to 500 jobs and 20 machines. Abadi et al.  proposed an improvement heuristic to minimize cycle time and Ronconi and Henriques  considered the minimization of total tardiness in a flowshop with blocking and presented some constructive heuristics with promising results. Furthermore, Pan and Wang  developed some effective heuristics based on PF approach. These PF-based heuristics are inspired from LR heuristic proposed by Liu and Revees  for the PFSP with the total flowtime criterion. In their work, the PF heuristic is combined with the partial NEH implementation and they called the heuristics as PF_NEH(x), WPF_NEH(x) and PW_NEH(x), where x is the number of sequences generated by considering the first x number of jobs in the initial order of jobs. In order not to ruin good characteristics of the PF heuristic, the NEH heuristic is applied to only the last $δ$ jobs. Their PW_NEH(x) heuristic with $x = 5$ was substantially better than NEH, MME, PFE, WPFE and PWE heuristics from the literature. Regarding the meta-heuristic algorithms for BFSP with the makespan criterion, the literature can be found in [18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33].
The makespan criterion is a firm-oriented performance measure, which aims at minimizing the idle times on the machines, thus resulting in a maximization of machine utilization. However, total flowtime and total tardiness criteria are both customer-oriented performance measures, which aim at minimizing the waiting times of jobs amongst machines in order to finish the jobs as early as possible, thus resulting in a maximization of the customer satisfaction. Since the tardiness is measured by the difference between due date and flowtime, both performance measures are equivalent.
For the total tardiness criterion, a few papers can be found in [34,35]. Regarding the total flowtime criterion, a few papers can be found in the literature. A hybrid harmony search is presented in . A discrete artificial bee colony algorithm is presented in . An iterated greedy algorithm is developed in , and a branch and bound is presented in  for solving small size of instances. Very recently, a GRASP and a discrete artificial bee colony (DABC_RCT) algorithm are developed in [40,41], which outperformed the existing algorithms from the literature.
In this paper, we present a variable block insertion heuristic (VBIH) algorithm to solve the BFSP with the total flowtime criterion. Through extensive computational analyses on Taillard’s well-known benchmark suite, we demonstrate that the proposed VBIH algorithm outperforms the recent best performing DABC_RCT algorithm from the literature. Ultimately, 52 out of 150 problem instances are further improved with substantial margins.
The rest of the paper is organized as follows. In Section 2, the blocking flowshop scheduling problem with speed-up method is formulated. Section 3 presents the components of the VBIH algorithm. Section 4 presents the design of experiment approach for parameter tuning. The computational results and comparisons are provided in Section 5. Finally, Section 6 gives the concluding remarks.

## 2. Blocking Flow Shop Scheduling Problem

In the blocking flowshop scheduling problem, $n$ jobs from the set $J = { 1 , 2 , .. , n }$ have to be processed on $m$ machines from the set $M = { 1 , 2 , .. , m }$ with the same permutation on each machine without any intermediate buffer. Each job $j$ has a processing time on machine $k$, which is denoted as $p j , k .$ The setup time is assumed to be included in the processing time. Only a single job can be processed on each machine. Since waiting times are not allowed in the flowshop due to no intermediate buffers, jobs cannot leave machines after completing their operations until next machines are free. In other words, if the next machine is busy, then the current job on the machine must be blocked since there is no intermediate buffer amongst machines. The goal is to obtain a permutation, which will be applied to each machine and the total flowtime (TFT) is to be minimized. Given a job sequence $π = { π 1 , π 2 , .. , π n }$, the departure time $d π j , k$ of job $π j$ on machine $k$ can be computed by following Ronconi  as follows:
$d π 1 , 0 = 0$
where denotes the starting time of job $j$ on the first machine. Since $C π j , m = d π j , m$ for all $j$, then the total flowtime of the sequence $π$ can be given as $T F T ( π ) = ∑ j = 1 n C π j , m$. Briefly, the objective is to determine a sequence $π *$ in the set of all sequences $Π$ such that .
There are two neighborhood structures in scheduling problems in general. These are based on insertion and swap neighborhood structures. As known, the computational complexity of both neighborhood structures is $O ( n 3 m )$. For the traditional PFSP with the total flowtime criterion, Lia et al.  proposed a speed-up method for the swap and insertion neighborhood structures. They showed that the proposed speed-up method makes a reduction in the CPU times up to 40 to 50 percent. Based on their idea, we develop a fast fitness function calculation for insertion and swap moves. Suppose that we have sequence $π$. We first calculate the departure times of each job on each machine and store them in a matrix denoted as $D π j , k$. Given the current sequence as $π = { 1 , 2 , 3 , 4 , 5 }$. Now, suppose that we would like to interchange job 3 at position 3 with job 4 at position 4. Due to the fact that the departure times are stored in $D π j , k$ in advance until job 3 at position 3, we do not need to re-calculate departure times until job 3 at position 3, again. In other words, after interchanging those two jobs, the departure times of the new sequence $π = { 1 , 2 , 4 , 3 , 5 }$ can be calculated as follows. First, we copy the departure times from $D π j , k$ matrix with . Then, we calculate the departure times starting from position 3 to 5 with .
In order to generalize it, we first determine two randomly chosen positons $p o s 1$ and $p o s 2$ such that $( p o s 1 < p o s 2 ) ∈ ( 1 , n )$. Our swap function, $π = S w a p ( π 0 , p o s 1 , p o s 2 )$, interchanges jobs $π j = p o s 1 0$ and $π j = p o s 2 0$; then, store the new sequence on a temporary sequence $π$. Finally, our fast fitness function, , copies the departure times from until position $j = p o s 1$ and then, re-calculates the departure times starting from position $p o s 1$ to the end of the remaining part of the sequence. After swapping jobs and storing them in a sequence $π$, the fast fitness function is given in Figure 1.
The same fast fitness function can be used for insertion moves, too. Before we get into details, we need to clarify that our insertion move function utilizes forward or backward insertion move with an equal probability of 0.5. We again determine two random positions $p o s 1$ and $p o s 2$ such that $( p o s 1 < p o s 2 ) ∈ ( 1 , n )$. Our insertion function, $π = I n s e r t ( π 0 , p o s 1 , p o s 2 )$, either removes job $π j = p o s 1 1$ at position $p o s 1$ and inserts it into $p o s 2$ in a temporary sequence $π$ (indicating a forward insertion move) or removes job $π j = p o s 2 1$ at position $p o s 2$ and inserts it into $pos 1$ in $π$ (indicating a backward insertion move). In both cases, one does not need to re-calculate the departure times until position $p o s 1$, which are copied from the $D π j , k$ matrix. In other words, $f f a s t ( π , p o s 1 )$ function in Figure 1 can also be used for insertion moves.

## 3. Variable Block Insertion Heuristic

Traditional local search algorithms are based on swap and insertion neighborhood structures. The swap operator exchanges two jobs in a sequence, whereas the insertion operator removes a job from a sequence and inserts it into another position in the sequence. Recently, local search algorithms, which are based on block moves, are presented for the single machine scheduling problem in the literature. A block move of 2-edge exchange was presented in Kirlik and Oguz . Then, Subramanian et al.  developed five different neighborhoods: swap, insertion, edge-insertion, 3-block insertion and 3-block reverse. The basic idea is to use larger neighborhood move operators rather than the swap and insertion move operators. Relying on this idea, Xu et al.  presented a neighborhood structure called a Block Move in which $l$ consecutive jobs (called a block) are inserted into another position in the sequence. They represent a block move by a , where represents the position of the first job of the block, $k$ denotes the target position of the block to be inserted and represents the size of the block. Note that one edge insertion, two edge-insertion and 3-block insertion corresponds to the block move neighborhoods with $l = 1$, $l = 2 ,$ and $l = 3$. Similarly, Gonzales and Vela  developed a variable neighborhood descent algorithm by using three block move neighborhoods were developed and used in a memetic algorithm.
Inspiring from the algorithms above, we propose a similar, but a different block insertion heuristic, which we call it a variable block insertion heuristic (VBIH) algorithm. We denote two block sizes as , where $b S m i n$ is the minimum block size and $b S m a x$ is the maximum block size. In addition, we define a block move insertion size with a maximum insertion move size denoted as $m S m a x$. The VBIH algorithm removes a block of jobs with size, $b S$, from the current sequence starting from $b S m i n = 1$, then it makes a number $m S m a x$ of block insertion moves randomly in the partial sequence, which we denote it as the block insertion move procedure, $( b I M ( ) )$. It chooses the best one amongst a number $m S m a x$ of block insertion moves. The sequence obtained after $b I M ( )$ procedure goes under a variable local search $( V L S )$, which is based on traditional insertion and swap neighborhood structures. If the new sequence obtained after the $V L S$ local search is better than the current sequence, it replaces the current sequence. As long as it improves, it keeps the same block size, i.e., $b S = b S$. Otherwise, the block size is incremented by one, i.e., $b S = b S + 1$ and a simulated annealing type of acceptance criterion is used to accept the inferior solution in order to escape from local minima. This process is repeated until the block size reaches at the maximum block size, i.e.,. The outline of the VBIH algorithm is given in Figure 2. Note that $π R$ is the reference sequence; $T$ is temperature parameter for the acceptance criterion, and $t P F _ N E H ( x )$ is a constructive heuristic providing an initial sequence to the VBIH algorithm. They will be explained in detail in the subsequent sections.

#### 3.1. Initial Solution

The initial solution for the VBIH algorithm is generated by the $t P F _ N E H ( x )$ heuristic, which is proposed for the first time in this paper in the literature. It is a novel modification of the $P F _ N E H ( x )$ heuristic presented in Pan and Wang . In the $P F _ N E H ( x )$ heuristic, the cost function to determine the next job to be scheduled is comprised of the total idle and blocking times. Note that the cost function devised for any constructive heuristic has a significant impact on the results. For this reason, Tasgetiren et al.  developed a $P F T _ N E H ( x )$ heuristic for the BFSP with the makespan criterion, which was inspired from the $P F _ N E H ( x )$ heuristic in . In , a new cost function was devised by adding the departure time of the last job on the last machine to the total idle and blocking times. In this paper, we extend the $P F T _ N E H ( x )$ heuristic to the total flowtime criterion and denote it as the $t P F _ N E H ( x )$ heuristic. As in the $P F T _ N E H ( x )$ heuristic, we consider the total idle and blocking times as a part of the cost function. In addition, we also consider the sum of the departure times on all machines of the last job that could be inserted into the partial sequence, which is one of the main contribution of this paper.
To implement the $t P F _ N E H ( x )$ heuristic, an initial order of jobs should be determined. To construct the initial order, we use the front delay and total processing times of each job as in Ribas et al. . The following measure is employed to construct the initial order of jobs of jobs:
$i O ( j ) = 2 m − 1 ( ∑ k = 1 m ( m − k ) p π j , k ) + ∑ k = 1 m p π j , k$
In order to establish the initial order of jobs, we sort the $i O ( j )$ values with an ascending order. Now, the number $x$ of new sequences can be generated from the initial order of jobs as follows. Since the first job has an impact on the solution quality, the first job of the initial order is taken as the first job of the new sequence and the $t P F _ N E H ( x )$ heuristic is applied to generate the new solution. Then, the second job of the initial order is taken as the first job of the new sequence and $t P F _ N E H ( x )$ heuristic is applied to generate another new solution. This is repeated $x$ times and the number $x$ of new sequences will be generated. Of course, the best one amongst them is chosen as the initial solution for the VBIH algorithm.
The proposed constructive heuristic can be summarized as follows. Suppose that $π i − 1$ jobs have already been scheduled and a partial sequence, $π = { π 1 , π 2 , .. , π i − 1 }$, is obtained. Clearly, job $π i$ will be the next job to be inserted into the partial sequence $π i − 1$. It can be any job from all jobs in the set $U$ of the unscheduled jobs. To select the job $π i$, we need a cost measure $( C M )$. For the BFSP with the total flowtime criterion, we propose a new cost function consisting of the total idle and blocking times as well as the sum of the departure times of job $π i$ on all machines. We first calculate the total idle and blocking time as follows:
$I T i = ∑ k = 1 m ( d i , k − d i − 1 , k − p π i , k )$
Then, we calculate the indexed sum of the departure times of job $π i$ on all machines as follows:
$S D i = ∑ k = 1 m m d i , k k + i ( m − k ) / ( n − 2 )$
Now, we define our cost function as follows:
$C M i = ( 1 − μ ) × I T i + μ × S D i$
Note that we also employ an index function, $m / ( k + i × ( m − k ) / ( n − 2 ) )$, to give a weight to departure time on each machine. Then, the job with the smallest sum of $C M i$ amongst all jobs in $U$ is determined as the job to be inserted to the partial sequence $π i − 1$. Figure 3 outlines the procedure of the proposed heuristic. As seen in Figure 3, the $t P F ( π * , h )$ procedure takes the initial sequence as $π *$ and the job-index as $y$ sent by the $t P F _ N E H ( x )$ heuristic. By using the job-index $y$, the x number of sequences will be generated.
Pan and Wang  showed that the $P F$ heuristic is very effective, but applying the $N E H$ heuristic to the whole sequence can worsen the objective function, i.e., total flowtime. To avoid it, they applied the $N E H$ heuristic to only the last $δ$ jobs. As can be seen above, the $t P F _ N E H ( x )$ heuristic has two parameters, namely, $δ$ and. Since the number x of sequences that will be generated are not so costly until the number of jobs is less than 200, i.e., $n ≤ 200$, in terms of CPU times, we determined it as ; else $x = 20$. Another distinction between $P F _ N E H ( x )$ and $t P F _ N E H ( x )$ is about how to choose the best one amongst x number of sequences. Since even the partial NEH implementation may result in an inferior solution when compared to $t P F$ heuristic, we check both solutions and keep the better one. Note that in all figures throughout the paper, $f ( π )$ and $r$ corresponds to the total flowtime (TFT) value of a sequence $π$ and a uniform random number between 0 and 1, respectively. The $t P F _ N E H ( x )$ heuristic is outlined in Figure 4.

#### 3.2. Block Insertion Move Procedure

procedure is a core function in the VBIH algorithm. It takes the sequence $π$, the block size, $b S$ and the maximum insertion move size, $m S m a x$ as parameters. The procedure randomly removes a block of jobs with size, $b S$ from the current sequence $π$, which is denoted as $π b$. Then, the partial sequence after removal will be denoted as $π p = J − { π b }$. Then, the procedure carries out a number $m S m a x$ of block insertion moves with the block size, $b S$. In other words, the block $π b$ is inserted in the partial sequence $π p$ randomly in which the maximum size of the insertion moves is $m S m a x$. Finally, it chooses the best one amongst a number $m S m a x$ of block insertion moves. The procedure is given in Figure 5.
In order to ease the understanding of the block insertion move procedure, we give the following example. Suppose that we have a current sequence $π = { 7 , 4 , 1 , 8 , 2 , 6 , 5 , 3 }$. In addition, suppose that the block size is $b S = 3$ and maximum insertion move size is $m S m a x = 3$. Suppose that we randomly choose a block $π b = { 8 , 2 , 6 }$. Then, the partial sequence will be $π p = { 7 , 4 , 1 , 5 , 3 }$. Without considering the total flowtime of the sequence $π$, we randomly choose three positions, for instance, 1, 2, 5, and insert the block in these positions. Hence we have three sequences as $π 1 = { 8 , 2 , 6 , 7 , 4 , 1 , 5 , 3 }$, $π 2 = { 7 , 8 , 2 , 6 , 4 , 1 , 5 , 3 }$, and $π 3 = { 7 , 4 , 1 , 5 , 8 , 2 , 6 , 3 }$. Amonst these three sequences we take the one with the lowest total flowtime criterion. Note that the same speed up methods explained before can be used to accelerate the insertion procedure. For example, after removing the block $π b = { 8 , 2 , 6 }$, $D j , k$ matrix of partial sequence $π p$ is once calculated, and then the fast fitness calculation procedure is used to accelerate the insertion procedure.

#### 3.3. Variable Local Search

The traditional variable neighborhood search (VNS) algorithm was developed in  and successfully applied to scheduling problems in [49,50,51,52,53]. Very recently, a variable local search (VLS) algorithm is developed by Ribas et al. [32,40,41]. The VLS algorithm is a novel and different from the traditional VNS algorithms in such a way that when a sequence is improved by any randomly chosen neighborhood structure, it switches to another neighborhood structure. For example, if a sequence is improved by the LS1 local search (i.e., swap neighborhood), it systematically switches to LS2 local search (i.e., insertion neighborhood), which is the difference between traditional VNS and VLS algorithms. As seen in Figure 6, if a sequence is improved by the local search type “LS”, it switches to $L S = 1 − L S$. Suppose that the $L S$ is randomly chosen as 1, then if the sequence is improved by the insertion neighborhood, the variable local search type is switched to 0 by $L S = 1 − 1 = 0$. This is different from the traditional VNS algorithms, where if a neighborhood improves, that neighborhood is kept for the search process and it switches to the second neighborhood if it fails, which is a common sense to follow. Note that, at least one time, both neighborhoods are ensured to be applied by using a $C o u n t e r$. The VLS local search is given in Figure 6.
Note that the VLS algorithm employs two powerful local search algorithms in the VBIH algorithm, namely, referenced insertion scheme (RIS) and referenced swap scheme (RSS). Briefly, in the VLS algorithm, the RIS local search is used as LS1 whereas the RSS local search is employed as LS2. The RIS and RSS local search algorithms are outlined in Figure 7 and Figure 8, respectively.
The RIS local search is an insertion local search neighborhood. The details can be found in [47,54,55,56,57,58,59]. Note that the fast fitness calculation is used in the RIS local search.
As seen in Figure 8, the RSS local search designates the job to be swapped by using the reference sequence $π R$ as in the RIS algorithm. Then, for each job $π k$, it exchanges job $π k$ with each $π i$ until the last job in the sequence. As long as the sequence improves after a number n of swap moves, the counter is fixed to 1 so that the search starts from the beginning again. Note that the fast fitness calculation is used in RSS local search, too.
After the local search phase, it should be decided if the new sequence is accepted as the incumbent sequence for the next iteration. A simple simulated annealing type of acceptance criterion is used with a constant temperature, which is suggested by Osman and Potts , as follows:
$T = ∑ j = 1 n ∑ k = 1 m p j , k 10 × n × m × τ P$
where $τ P$ is a parameter to be adjusted.

## 4. Parameter Tuning

In this section, we first determine the parameters of the PFT_NEH(x) heuristic through a design of experiment (DOE) approach . Then, we again make a design of experiment for the proposed VBIH algorithm in order to determine its parameters.

#### 4.1. Parameter Tuning of PFT_NEX(x) Heuristic

As mentioned before, since the number x of sequences generated are not so costly until $n ≤ 200$ in terms of CPU times, we determined it as else $x = 20$. Then, PFT_NEX(x) heuristic has two important parameters. Namely, $μ$ and $δ$. To determine $μ$ and $δ$ parameters, we carry out a design of experiments (DOE) . To do it, we generate random instances with the method proposed in . In other words, random instances are generated for each combination of $n ∈ { 20 , 50 , 100 , 200 , 500 }$ and $m ∈ { 5 , 10 , 20 }$. Five instances are generated for each job and machine combination, respectively. Ultimately, we obtained 75 instances for each pair of job and machine size. We consider two parameters, namely, the weight of the cost function $μ$ and the size of the partial NEH heuristic $δ$. We have taken $μ$ with 21 levels as and $δ$ with 10 levels as . We conducted a full factorial design of experiments resulting in $21 × 10 = 210$ treatments. For each job and machine combination, each instance is run for 210 treatments (210 $P F T _ N E X ( x )$ heuristics with $μ$ and $δ$ values). The relative percent deviation is calculated as follows:
$R P D = ∑ i = 1 210 ( C i − C m i n C m i n ) * 100 .$
where $C i$ is the total flowtime generated by each treatment and $C m i n$ is the minimum total flowtime found amongst 210 treatments. This is repeated for five instances and RPD values are averaged for each treatment. Then the response variable is obtained by averaging the RPD values of 15 different job and machine combinations for each treatment. The DOE is coded in Visual C++13 and carried out on an Intel(R) Core(TM) i7-2600 CPU with 3.40 GHz PC with 8.00 GB memory.
Once the response variable was determined for each treatment, we analyze the main effects plot of parameters, which is given in Figure 9. Figure 9 suggests that $μ$ (parW) and $δ$ (parNEH) should be taken as 0.35 and 15, respectively.
However, Figure 9 suggests that $μ$ values with 0.25, 0.30, 0.35, 0.40, 0.55 and 0.60 with $δ = 15$ generate very good and diversified results on random benchmark instances. Table 1 summarizes the computational results of those $μ$ values as well as the CPU times in seconds. It can be seen in Table 1 that $μ = 0.30$ and $μ = 0.35$ provided the best results as Figure 9 suggested. However, provide some diversified solutions, too. Note that the $P F T _ N E H ( x )$ heuristics are substantially better than the HPF2 heuristic presented in  since it generated the ARPDs of 1.473 and 1.468, respectively when compared to the ARPD of 3.287. In addition, the same authors proposed GRASP-based algorithms as well as NHPF1 and NHPF2 heuristics for the initial solution procedures in . $P F T _ N E H ( x )$ heuristics are also substantially better than NHPF1 and NHPF2 heuristics since the ARPDs of 1.473 percent and 1.468 percent are much better than those ARPDs of 3.018 percent and 2.797 percent. In addition to above, $P F T _ N E H ( x )$ heuristics were able to further improve some larger instances in about 0.760 s on overall average.

#### 4.2. Parameter Tuning of VBIH Algorithm

In this section, we again present a DOE approach for parameter setting of the VBIH algorithms. In order to carry out experiments, we generate random instances with the method proposed in . In other words, random instances are generated for each combination of $n ∈ { 20 , 50 , 100 , 200 , 500 }$ and $m ∈ { 5 , 10 , 20 }$. Five instances are generated for each job and machine combination, respectively. Ultimately, we obtained 75 instances for each pair of job and machine size. We consider three parameters in the DOE approach. These are maximum block size ($b S m a x$), maximum block insertion move size $( m S m a x )$; and temperature adjustment parameter ($τ P$). We have taken the maximum block size with four levels as $b S m a x ∈ ( 4 , 8 , 12 , 16 )$; the maximum block insertion move size with three levels as and the temperature adjustment parameter with five levels as . We conducted a full factorial design of experiments resulting in $4 × 3 × 5 = 60$ treatments. For each job and machine combination, each instance is run for 60 treatments with a maximum CPU time equal to $T m a x = 10 × n × m$ milliseconds. The relative percent deviation is calculated as follows:
$R P D = ∑ i = 1 60 ( C i − C m i n C m i n ) * 100 .$
where $C i$ is the total flowtime generated by each treatment and $C m i n$ is the minimum total flowtime found amongst 60 treatments. This is repeated for five instances and RPD values are averaged for each treatment. Then the response variable is obtained by averaging the RPD values of 15 different job and machine combinations for each treatment. The DOE is coded in Visual C++13 and carried out on an Intel (R) Core (TM) i7-2600 CPU with 3.40 GHz PC with 8.00 GB memory.
Once the response variable was determined for each treatment, we analyze the main effects plots of the parameters, which are given in Figure 10. Figure 10 suggests that the $b S m a x$ should be taken as $b S m a x = 16$; $m S m a x$ should be taken as $m S m a x = 0.1 * ( n − b S m a x )$; and $τ P$ should be taken as $τ P = 0.2$.
The main effects plot might not be meaningful when there are significant interactions between the parameters. For this reason, the ANOVA table should be analyzed to see whether interactions are significant or not. The ANOVA results are given in Table 2. From Table 2, it can be seen that $b S m a x * m S m a x$ interaction is found to be significant because of the very high magnitude of $F$ ratio and the p-value being less than α = 0.05 level. For these reasons, we look at the $b S m a x * m S m a x$ interaction plot, which is given in Figure 11.
As seen in Figure 11, $b S m a x = 16$ with generated the lowest ARPD. For this reason, we decided to take the parameters as follows: $b S m a x = 16$; $m S m a x = 0.3 * ( n − b S m a x )$; and $τ P = 0.2$.

## 5. Computational Results

To test the performance of the VBIH algorithms proposed, extensive experimental evaluations and comparisons with other powerful methods are provided based on the well-known flowshop benchmark suite of Taillard . The benchmark set is composed of 15 groups of the given problems with the size ranging from 20 jobs and 5 machines to 500 jobs and 20 machines, and each group consists of ten instances. However, in , these benchmark problems are extended to 200 × 5, 500 × 5 and 500 × 10 sizes with each containing 10 instances. Ultimately, we employ 150 instances as in the DABC_RCT algorithm in . We treat them as blocking flow shop scheduling problems with the total flowtime criterion. In the experimental tests, all algorithms are coded in Visual C++13 and carried out on an Intel(R) Core(TM) i7-2600 CPU with 3.40 GHz PC with 8.00GB memory. Note that the maximum CPU time is fixed at $T m a x = 100 × n × m$ milliseconds for all algorithms compared. We compare to the following best performing algorithms from the literature:
• DABC_RCT in . The DABC_RCT algorithm is a very efficient algorithm and has three phases. In the employed bee phase, the TNO procedure is employed with the VLS local search. In the onlooker bee phase, the path-relinking approach is employed to generate the onlooker bees. In the scout bee phase, HPF2 is used to generate the scout bees. We refer to  for the details. We have coded the DABC_RCT algorithm in Visual C+13 to have a fair comparison. Note that the DABC_RCT algorithm uses HPF2 heuristic as an initial solution. Since our PFT_NEH(x) heuristic is substantially better than HPF2 heuristic, we employ the PFT_NEH(x) heuristic with $μ = 0.35$ and $δ = 15$ as one of the solution in the population. The rest of the population individuals are constructed randomly as suggested in the DABC_RCT algorithm and we denote it as the DABC*_RCT algorithm to have a fair comparison. The same parameters are also used which are suggested in the DABC_RCT algorithm . Note that fast fitness calculation is employed to accelerate the insertion and swap neighborhood structures in the VLS local search they employed in the TNO procedure.
• IG_RIS algorithm in [47,54,55,56,57,58,59]. To be fair again, we employ PFT_NEH(x) heuristic with $μ = 0.35$ and $δ = 15$ as an initial solution in the IG_RIS algorithm. IG_RIS algorithm relies on the destruction and construction procedure, where number of jobs is removed from a solution and they are reinserted to the partial solution sequentially. Then RIS local search is applied to the solution obtained after destruction and construction procedure. Note that fast fitness calculation is employed to accelerate the RIS insertion local search as in this paper. It is also employed in the destruction and construction procedure, too.
• VBIH algorithms in this paper. Since the PFT_NEH(x) heuristics provide very diversified initial solutions, we run the VBIH algorithm with $μ$ values with 0.25, 0.30, 0.35, 0.40, 0.55 and 0.60 with $δ = 15$. Then we denote them as VBIH1, VBIH2, VBIH3, VBIH4, VBIH5 and VBIH6. In addition, when the maximum block size is equal to 1, the VBIH algorithm becomes an iterated local search. In other words, the current solution is perturbed with several insertion moves and then the VLS local search is applied to the solution after perturbation. Then, the acceptance criterion is imposed to the solution obtained. We denote this variant of the VBIH algorithm as IVLS algorithm.
Each instance is run for five (R) independent replications and the relative percentage deviation.
RPD is computed as follows:
$A R P D = ∑ i = 1 R ( H − B K S B K S ) * 100 / R$
where are the total flowtime value generated by the algorithms in each run, the most recent best-known solution value reported in , and the number of runs, respectively. In addition, the ARPD for each instance, totally 150, is recorded to make statistical analyses.
The computational results are given in Table 3. The first observation from Table 3 that the IG_RIS and DABC_RCT algorithms are not competitive to the DABC*_RCT and VBIH variants. Especially, even though the fast fitness calculation is employed in the IG_RIS algorithm, which is known as one of the best algorithms in the scheduling literature, it could not be able to generate competitive results. In fact, its local search is based on only the insertion neighborhood, which is very effective for the makespan criterion. However, the results in Table 3 indicate that the swap neighborhood should be used in algorithms designed for the total flowtime criterion. The second observation is the performance of the DABC*_RCT algorithm, which is quite competitive to the VBIH variants. The overall ARPD is decreased from 0.593 percent to 0.376 percent due to the use of the PFT_NEH(x) heuristic as a solution in the initial population. It indicates that the proposed PFT_NEH(x) heuristic was so effective on the results of the DABC*_RCT algorithm. Amongst the VBIH variants, the first four variants were able to generate results ranging from 0.303 percent to 0.285 percent. As can be seen from Table 3, especially, the larger instances with sizes 500 × 20, 500 × 5 and 500 × 10 were further improved by the first four variants of the VBIH algorithms.
In order to see the statistical difference between algorithms, we provide the interval plot of the algorithms compared in Figure 12. Since the 95% confidence intervals of DABC*_RCT and VBIH variants do not overlap, we can conclude that the DABC*_RCT and the VBIH variants generated results, which are statistically significant to those results generated by the IG_RIS and DABC_RCT algorithms. When we look at the confidence intervals of the DABC*_RCT and VBIH variants, there are overlaps between the algorithms. However, an overlap does not mean that there is no difference. There may be statistically significant difference even if there is an overlap . To determine the difference, the paired t-tests should be used .
The results of the paired t-tests are given in Table 4. If the 95% confidence interval for the mean difference between the two compared algorithms does not include zero values, it indicates that there is a difference between the two algorithms compared. In addition, p-values, which are smaller than α = 0.05 level, further suggest that the compare algorithms perform differently. As can be seen from Table 4, the IVLS, VBIH1, VBIH2, VBIH3 and VBIH4 algorithms are statistically better than the DABC*_RCT algorithm. However, the VBIH5 and VBIH 6 algorithms are statistically equivalent.
Finally, in Table 5, we provide the best solutions found by each algorithm. 52 out of 150 problems instances are further improved together with 15 solutions being equal during in this study. All the results and permutations are available based on request.

## 6. Conclusions

This paper presents a VBIH algorithm to solve the blocking flowshop scheduling problem with the total flowtime criterion. To the best of our knowledge, this is the first reported application of the VHIH algorithm to the blocking flowshop scheduling problem with the total flowtime criterion. Once an initial solution is constructed, the VBIH algorithm begins with a minimum block size of one. It removes the block from the current sequence and inserts the block into the partial sequence with a predetermined move size. Then, a variable local search (VLS) is applied to solution obtained after several block insertions. As long as the solution improves, it keeps the same block size. However, if the solution does not improve, the block size is increased by one. This process is repeated until the block size reaches at the maximum block size. In addition, we present a novel constructive heuristic based on profile fitting heuristic from the literature with results improving especially some larger instances in a few seconds. Parameters of the constructive heuristic and the VBIH algorithm are determined through a design of experiment approach. Extensive computational results on Taillard’s well-known benchmark suite show that the proposed VBIH algorithm outperforms the discrete artificial bee colony algorithm, which has recently been proposed with the new best known solutions. Ultimately, 52 out of the 150 best known solutions are further improved with substantial margins.

## Supplementary Materials

The supplementary materials are available online at https://www.mdpi.com/1999-4893/9/4/71/s1.

## Author Contributions

M. Fatih Tasgetiren and Quan-Ke Pan and Damla Kizilay have written the C++ codes. Damla Kizilay and Gao Kaizhou have carried out all the DOE runs and prepared the analyses of DOE runs. M. Fatih Tasgetiren and Quan-Ke Pan have written the paper. All authors have read and approved the final manuscript.

## Conflicts of Interest

The authors declare no conflict of interest.

## References

1. Błażewicz, J.; Ecker, K.H.; Pesch, E.; Schmidt, G.; Weglarz, J. Handbook on Scheduling: From Theory to Applications; Springer: Berlin/Heidelberg, Germany, 2007. [Google Scholar]
2. Pan, Q.K.; Ruiz, R. An estimation of distribution algorithm for lot-streaming flow shop problems with setup times. Omega 2012, 40, 166–180. [Google Scholar] [CrossRef]
3. Vallada, E.; Ruiz, R. Genetic algorithms with path relinking for the minimum tardiness permutation flowshop problem. Omega 2010, 38, 57–67. [Google Scholar] [CrossRef]
4. Ruiz-Torres, A.J.; Ho, T.J.; Ablanedo-Rosas, J.H. Makespan and workstation utilization minimization in a flowshop with operations flexibility. Omega 2011, 39, 273–282. [Google Scholar] [CrossRef]
5. Grabowski, J.; Pempera, J. Sequencing of jobs in some production system. Eur. J. Oper. Res. 2000, 125, 535–550. [Google Scholar] [CrossRef]
6. Ronconi, D.P. A note on constructive heuristics for the flowshop problem with blocking. Int. J. Prod. Econ. 2004, 87, 39–48. [Google Scholar] [CrossRef]
7. Hall, N.G.; Sriskandarajah, C. A survey of machine scheduling problems with blocking and no-wait in process. Oper. Res. 1996, 44, 510–525. [Google Scholar] [CrossRef]
8. Graham, R.L.; Lawler, E.L.; Lenstra, J.K.; Rinnooy Kan, A.H.G. Optimization and approximation in deterministic sequencing and scheduling: A survey. Ann. Discret. Math. 1979, 5, 287–362. [Google Scholar]
9. Gilmore, P.C.; Lawler, E.L.; Shmoys, D.B. Well-solved special cases. In The Traveling Salesman Problem: A Guided Tour of Combinatorial Optimization; Lawler, E.L., Lenstra, K.L., Rinooy Kan, A.H.G., Shmoys, D.B., Eds.; John Wiley & Sons: Hoboken, NJ, USA, 1985; pp. 87–143. [Google Scholar]
10. McCormick, S.T.; Pinedo, M.L.; Shenker, S.; Wolf, B. Sequencing in an assembly line with blocking to minimize cycle time. Oper. Res. 1989, 37, 925–936. [Google Scholar] [CrossRef]
11. Leisten, R. Flowshop sequencing problems with limited buffer storage. Int. J. Prod. Res. 1990, 28, 2085–2100. [Google Scholar] [CrossRef]
12. Nawaz, M.; Enscore, E.E.J.; Ham, I. A heuristic algorithm for the m-machine, n-job flow shop sequencing problem. Omega 1983, 11, 91–95. [Google Scholar] [CrossRef]
13. Ronconi, D.P.; Armentano, V.A. Lower bounding schemes for flowshops with blocking in-process. J. Oper. Res. Soc. 2001, 52, 1289–1297. [Google Scholar] [CrossRef]
14. Abadi, I.N.K.; Hall, N.G.; Sriskandarajh, C. Minimizing cycle time in a blocking flowshop. Oper. Res. 2000, 48, 177–180. [Google Scholar] [CrossRef]
15. Ronconi, D.P.; Henriques, L.R.S. Some heuristic algorithms for total tardiness minimization in a flowshop with blocking. Omega 2009, 37, 272–281. [Google Scholar] [CrossRef]
16. Pan, Q.K.; Wang, L. Effective heuristics for the blocking flowshop scheduling problem with makespan minimization. Omega 2012, 40, 218–229. [Google Scholar] [CrossRef]
17. Liu, J.Y.; Reeves, C.R. Constructive and composite heuristic solutions to the P// ∑ Ci scheduling problem. Eur. J. Oper. Res. 2001, 132, 439–452. [Google Scholar] [CrossRef]
18. Caraffa, V.; Ianes, S.; Bagchi, T.P.; Sriskandarajah, C. Minimizing makespan in a blocking flowshop using genetic algorithms. Int. J. Prod. Econ. 2001, 70, 101–115. [Google Scholar] [CrossRef]
19. Ronconi, D.P. A branch-and-bound algorithm to minimize the makespan in a flowshop problem with blocking. Ann. Oper. Res. 2005, 138, 53–65. [Google Scholar] [CrossRef]
20. Taillard, E. Benchmarks for basic scheduling problems. Eur. J. Oper. Res. 1993, 64, 278–285. [Google Scholar] [CrossRef]
21. Grabowski, J.; Pempera, J. The permutation flow shop problem with blocking. A tabu search approach. Omega 2007, 35, 302–311. [Google Scholar] [CrossRef]
22. Wang, L.; Zhang, L.; Zheng, D. An effective hybrid genetic algorithm for flow shop scheduling with limited buffers. Comput. Oper. Res. 2006, 33, 2960–2971. [Google Scholar] [CrossRef]
23. Liu, B.; Wang, L.; Jin, Y. An effective hybrid PSO-based algorithm for flow shop scheduling with limited buffers. Comput. Oper. Res. 2008, 35, 2791–2806. [Google Scholar] [CrossRef]
24. Qian, B.; Wang, L.; Huang, D.X.; Wang, X. An effective hybrid DE-based algorithm for flow shop scheduling with limited buffers. Int. J. Prod. Res. 2009, 47, 1–24. [Google Scholar] [CrossRef]
25. Liang, J.J.; Pan, Q.; Tiejun, C.; Wang, L. Solving the blocking flow shop scheduling problem by a dynamic multi-swarm particle swarm optimizer. Int. J. Adv. Manuf. Technol. 2011, 55, 755–762. [Google Scholar] [CrossRef]
26. Wang, L.; Pan, Q.K.; Tasgetiren, M.F. A Hybrid Harmony Search Algorithm for the Blocking Permutation Flow Shop Scheduling Problem. Comput. Ind. Eng. 2011, 61, 76–83. [Google Scholar] [CrossRef]
27. Wang, L.; Pan, Q.K.; Suganthan, P.N.; Wang, W.H.; Wang, Y.M. A novel hybrid discrete differential evolution algorithm for blocking flow shop scheduling problems. Comput. Oper. Res. 2010, 37, 509–520. [Google Scholar] [CrossRef]
28. Ribas, I.; Companys, R.; Tort-Martorell, X. An iterated greedy algorithm for the flowshop scheduling with blocking. Omega 2011, 39, 293–301. [Google Scholar] [CrossRef]
29. Wang, C.; Song, S.; Gupta, J.N.D.; Wu, C. A three-phase algorithm for flowshop scheduling with blocking to minimize makespan. Comput. Oper. Res. 2012, 39, 2880–2887. [Google Scholar] [CrossRef]
30. Lin, S.W.; Ying, K.C. Minimizing makespan in a blocking flowshop using a revised artificial immune system algorithm. Omega 2013, 41, 383–389. [Google Scholar] [CrossRef]
31. Pan, Q.K.; Wang, L.; Sang, H.Y.; Li, J.Q.; Liu, M. A high performing memetic algorithm for the flowshop scheduling problem with blocking. IEEE Trans. Autom. Sci. Eng. 2013, 10, 741–756. [Google Scholar]
32. Ribas, I.; Companys, R.; Tort-Martorell, X. A competitive variable neighbourhood search algorithm for the blocking flow shop problem. Eur. J. Ind. Eng. 2013, 7, 729–754. [Google Scholar] [CrossRef]
33. Ding, J.-Y.; Song, S.; Gupta, N.D.J.; Wang, C.; Zhang, R.; Wu, C. New block properties for flowshop scheduling with blocking and their application in an iterated greedy algorithm. Int. J. Prod. Res. 2015, 54, 4759–4772. [Google Scholar] [CrossRef]
34. Armentano, V.A.; Ronconi, D.P. Minimização do tempo total de atraso no problema de flowshop com buffer zero através de busca tabu. Gestao Produçao 2000, 7, 352–362. (In Portuguese) [Google Scholar] [CrossRef]
35. Ribas, I.; Companys, R.; Tort-Martorell, X. An efficient iterated local search algorithm for the total tardiness blocking flow shop problem. Int. J. Prod. Res. 2013, 51, 5238–5252. [Google Scholar] [CrossRef]
36. Wang, L.; Pan, Q.K.; Tasgetiren, M.F. Minimizing the total flow time in a flow shop with blocking by using hybrid harmony search algorithms. Expert Syst. Appl. 2010, 37, 7929–7936. [Google Scholar] [CrossRef]
37. Deng, G.; Xu, Z.; Gu, X. A discrete artificial bee colony algorithm for minimizing the total flow time in the blocking flow shop scheduling. Chin. J. Chem. Eng. 2012, 20, 1067–1073. [Google Scholar] [CrossRef]
38. Khorasanian, D.; Moslehi, G. An iterated greedy algorithm for solving the blocking flowshop scheduling problem with total flow time criteria. Int. J. Ind. Eng. Prod. Res. 2012, 23, 301–308. [Google Scholar]
39. Moslehi, G.; Khorasanian, D. Optimizing blocking flow shop scheduling total completion time criterion. Comput. Oper. Res. 2013, 40, 1874–1883. [Google Scholar] [CrossRef]
40. Ribas, I.; Companys, R. Efficient heuristic algorithms for the blocking flow shop scheduling problem with total flow time minimization. Comput. Ind. Eng. 2015, 87, 30–39. [Google Scholar] [CrossRef]
41. Ribas, I.; Companys, R. Xavier Tort-Martorell, An efficient Discrete Artificial Bee Colony algorithm for the blocking flow shop problem with total flowtime minimization. Expert Syst. Appl. 2015, 42, 6155–6167. [Google Scholar] [CrossRef][Green Version]
42. Lia, X.; Wang, Q.; Wu, C. Efficient composite heuristics for total flowtime minimization in permutation flowshops. Omega 2009, 37, 155–164. [Google Scholar] [CrossRef]
43. Kirlik, G.; Oguz, C. A Variable Neighborhood Search for Minimizing Total Weighted Tardiness with Sequence Dependent Setup Times on a Single Machine. Comput. Oper. Res. 2012, 39, 1506–1520. [Google Scholar] [CrossRef]
44. Subramanian, A.; Battarra, M.; Potts, C.N. An Iterated Local Search heuristic for the single machine total weighted tardiness scheduling problem with sequence-dependent setup times. Int. J. Prod. Res. 2014, 52, 2729–2742. [Google Scholar] [CrossRef]
45. Xu, H.; Lü, Z.; Cheng, T.C.E. Iterated Local Search for single-machine scheduling with sequence dependent setup times to minimize total weighted tardiness. J. Sched. 2014, 17, 271–287. [Google Scholar] [CrossRef]
46. González, M.A.; Vela, C.R. An efficient memetic algorithm for total weighted tardiness minimization in a single machine with setups. Appl. Soft Comput. 2015, 37, 506–518. [Google Scholar] [CrossRef]
47. Tasgetiren, M.F.; Kizilay, D.; Pan, Q.K.; Suganthan, P.N. Iterated Greedy Algorithms for the Blocking Flowshop Scheduling Problem with Makespan Criterion. Comput. Oper. Res. 2016. [Google Scholar] [CrossRef]
48. Mladenovic, N.; Hansen, P. Variable neighborhood search. Comput. Oper. Res. 1997, 24, 1097–1100. [Google Scholar] [CrossRef]
49. Tasgetiren, M.F.; Liang, Y.-C.; Sevkli, M.; Gencyilmaz, G. A particle swarm optimization algorithm for makespan and total flowtime minimization in the permutation flowshop sequencing problem. Eur. J. Oper. Res. 2007, 177, 1930–1947. [Google Scholar] [CrossRef]
50. Pan, Q.-K.; Tasgetiren, M.F.; Liang, Y.-C. A Discrete Particle Swarm Optimization Algorithm for the No-Wait Flowshop Scheduling Problem with Makespan and Total Flowtime Criteria. Comput. Oper. Res. 2008, 35, 2807–2839. [Google Scholar] [CrossRef]
51. Pan, Q.-K.; Wang, L.; Tasgetiren, M.F.; Zhao, B.-H. A hybrid discrete particle swarm optimization algorithm for the no-wait flow shop scheduling problem with makespan criterion. Int. J. Adv. Manuf. Technol. 2008, 38, 337–347. [Google Scholar] [CrossRef]
52. Tasgetiren, M.F.; Liang, Y.-C.; Sevkli, M.; Gencyilmaz, G. Particle swarm optimization and differential evolution for single machine total weighted tardiness problem. Int. J. Prod. Res. 2006, 44, 4737–4754. [Google Scholar] [CrossRef]
53. Tasgetiren, M.F.; Sevkli, M.; Liang, Y.-C.; Yenisey, M.M. A particle swarm optimization and differential evolution algorithms for job shop scheduling problem. Int. J. Oper. Res. 2006, 3, 120–135. [Google Scholar]
54. Tasgetiren, M.F.; Pan, Q.K.; Suganthan, P.N.; Buyukdagli, O. A variable iterated greedy algorithm with differential evolution for the no-idle permutation flowshop scheduling problem. Comput. Oper. Res. 2013, 40, 1729–1743. [Google Scholar] [CrossRef]
55. Pan, Q.K.; Tasgetiren, M.F.; Liang, Y.C. A discrete differential evolution algorithm for the permutation flowshop scheduling problem. Comput. Ind. Eng. 2008, 55, 795–816. [Google Scholar] [CrossRef]
56. Tasgetiren, M.F.; Pan, Q.K.; Liang, Y.C. A discrete differential evolution algorithm for the single machine total weighted tardiness problem with sequence dependent setup times. Comput. Oper. Res. 2009, 36, 1900–1915. [Google Scholar] [CrossRef]
57. Tasgetiren, M.F.; Pan, Q.K.; Suganthan, P.N.; Chen, A.H.L. A discrete artificial bee colony algorithm for the total flowtime minimization in permutation flow shops. Inf. Sci. 2011, 181, 3459–3475. [Google Scholar] [CrossRef]
58. Tasgetiren, M.F.; Pan, Q.K.; Suganthan, P.N.; Oner, A. A Discrete Artificial Bee Colony Algorithm for the No-Idle Permutation Flowshop Scheduling Problem with the Total Tardiness Criterion. Appl. Math. Model. 2013, 37, 6758–6779. [Google Scholar] [CrossRef]
59. Tasgetiren, M.F.; Pan, Q.K.; Suganthan, P.N.; Chua, T.J. A Differential Evolution Algorithm for the No-Idle Flowshop Scheduling Problem with Total Tardiness Criterion. Int. J. Prod. Res. 2011, 49, 5033–5050. [Google Scholar] [CrossRef]
60. Osman, I.; Potts, C. Simulated annealing for permutation flow-shop scheduling. Omega 1989, 17, 551–557. [Google Scholar] [CrossRef]
61. Montgomery, D.C. Design and Analysis of Experiments; John Wiley & Sons: Hoboken, NJ, USA, 2008. [Google Scholar]
62. Pan, Q.K.; Ruiz, R. Local search methods for the flowshop scheduling problem with flowtime minimization. Eur. J. Oper. Res. 2012, 222, 31–43. [Google Scholar] [CrossRef]
63. Schenker, N.; Gentleman, J.F. On judging the significance of differences by examining the overlap between confidence intervals. Am. Stat. 2001, 55, 182–186. [Google Scholar] [CrossRef]
Figure 1. $f f a s t ( π , p o s 1 )$ function.
Figure 1. $f f a s t ( π , p o s 1 )$ function.
Figure 2. Variable block insertion heuristic.
Figure 2. Variable block insertion heuristic.
Figure 3. tPF heuristic.
Figure 3. tPF heuristic.
Figure 4. tPF_NEH(x) heuristic.
Figure 4. tPF_NEH(x) heuristic.
Figure 5. Block insertion procedure.
Figure 5. Block insertion procedure.
Figure 6. Variable local search (VLS) algorithm.
Figure 6. Variable local search (VLS) algorithm.
Figure 7. Referenced insertion scheme (RIS) local search.
Figure 7. Referenced insertion scheme (RIS) local search.
Figure 8. Referenced swap scheme (RSS) local search.
Figure 8. Referenced swap scheme (RSS) local search.
Figure 9. Main effects plot.
Figure 9. Main effects plot.
Figure 10. Main Effects Plots of Parameters.
Figure 10. Main Effects Plots of Parameters.
Figure 11. Interaction plot.
Figure 11. Interaction plot.
Figure 12. Interval plot of algorithms compared.
Figure 12. Interval plot of algorithms compared.
Table 1. Average relative percentage deviations for PFT_NEH(x) heuristics.
Table 1. Average relative percentage deviations for PFT_NEH(x) heuristics.
$μ$ Values and CPU (s)
n × mHPF2 NHPF1 NHPF2 $0.25$CPU (s)$0.30$CPU (s)$0.35$CPU (s)$0.40$CPU (s)$0.55$CPU (s)$0.60$CPU (s)
20 × 54.0382.9283.0591.3680.0021.1900.0001.1580.0031.0140.0031.2640.0001.1900.002
20 × 103.1562.7192.3401.0690.0001.2280.0031.0050.0021.1540.0001.1750.0001.0050.003
20 × 203.9892.8572.7661.0110.0020.9420.0031.0160.0031.0630.0031.0090.0021.0470.003
50 × 53.9293.9033.5283.0290.0222.7750.0232.7740.0243.2040.0252.8810.0222.9150.025
50 × 103.6644.1913.6652.7180.0392.6510.0392.6080.0412.6710.0392.6550.0412.8710.041
50 × 205.3184.3984.2372.4530.0782.4090.0772.2740.0732.3100.0752.2100.0802.2580.078
100 × 53.8163.7573.6682.9890.1162.7430.1142.7020.1252.6920.1162.8220.1162.9130.120
100 × 104.0874.4503.9642.6110.2112.7830.2162.5980.2132.5690.2132.7550.2232.8630.217
100 × 205.5544.4284.5392.2230.4312.0300.4342.1250.4332.0640.4332.3530.4342.2070.436
200 × 102.3622.5051.9151.0571.7300.9441.7401.0531.7371.0701.7361.1601.7311.3361.736
200 × 202.8112.6762.4780.7773.5530.6693.5800.8893.5940.7803.5521.0003.5521.1223.555
500 × 201.5951.4641.533−0.1772.352−0.1582.402−0.1112.358−0.0822.3490.0662.3500.0482.352
200 × 52.3942.2601.9361.4000.9171.2920.9201.2640.9171.3140.9191.7270.9171.8330.920
500 × 51.1911.3301.0270.5450.7550.3560.7580.3170.7500.4750.7750.8250.7610.9160.758
500 × 101.3981.3991.3070.2721.1940.2471.1950.3531.1890.2481.1880.4771.1910.5641.191
Average3.2873.0182.7971.5560.7601.4730.7671.4680.7641.5030.7621.6250.7611.6730.762
Bold: better results.
Table 2. ANOVA table.
Table 2. ANOVA table.
$S o u r c e$$D F$$F$$p$
$b S m a x$30.0953700.0953700.03179098.550.00
$m S m a x$20.0198730.0198730.00993730.800.00
$t P$40.0006760.0006760.0001690.520.72
$b S m a x * m S m a x$60.0399300.0399300.00665520.630.00
$b S m a x * t P$120.0023950.0023950.0002000.620.81
$m S m a x * t P$80.0015850.0015850.0001980.610.76
$E r r o r$240.0077420.0077420.000323--
$T o t a l$590.167569----
Table 3. Average relative percentage deviations for algorithms compared.
Table 3. Average relative percentage deviations for algorithms compared.
n × mIG_RISDABC_RCTIVLSDABC*_RCTVBIH1VBIH2VBIH3VBIH4VBIH5VBIH6
20 × 50.0490.0040.0680.0060.0010.0000.0000.0000.0000.000
20 × 100.0160.0210.1510.0310.0000.0000.0000.0000.0000.000
20 × 200.0100.0150.0320.0020.0000.0000.0000.0000.0000.000
50 × 50.9010.7880.7130.4900.4180.3540.3460.3760.2960.325
50 × 100.8190.7520.9160.7520.5620.4550.4570.4240.4630.502
50 × 200.5210.5610.6520.4900.3180.3780.3160.3550.3300.321
100 × 51.5551.1351.1330.9370.6500.7640.7090.6500.6960.714
100 × 101.6391.3011.3581.2851.0701.1791.1261.0981.1121.118
100 × 201.1471.2790.9270.9830.7590.8330.7990.9030.7960.750
200 × 100.6330.5590.2360.3120.4270.2430.3770.2930.2970.308
200 × 200.3370.5810.1930.2010.1460.2270.2110.2550.4300.421
500 × 20−0.2290.426−0.381−0.274−0.353−0.374−0.395−0.303−0.192−0.185
200 × 50.8540.4700.3730.3580.3920.3250.3410.3720.3880.401
500 × 50.2590.397−0.014−0.0220.150−0.012−0.053−0.0420.2990.369
500 × 100.2340.607−0.0330.0920.000−0.0310.035−0.0460.1740.282
Average0.5830.5930.4220.3760.3030.2890.2850.2890.3390.355
Bold: better results.
Table 4. Paired t-test for variable block insertion heuristic (VBIH) variants versus discrete artificial bee colony (DABC)*_RCT algorithm.
Table 4. Paired t-test for variable block insertion heuristic (VBIH) variants versus discrete artificial bee colony (DABC)*_RCT algorithm.
Algorithm vs. algorithm95% CI for Mean Difference p-Value
IVLS − DABC*_RCT(0.0041, 0.0875)0.032
VBIH1 − DABC*_RCT(−0.1162, −0.0298)0.001
VBIH2 − DABC*_RCT(−0.1242, −0.0486)0.000
VBIH3 − DABC*_RCT(−0.1193, −0.0639)0.000
VBIH4 − DABC*_RCT(−0.1258, −0.0474)0.000
VBIH5 − DABC*_RCT(−0.0843, 0.0117)0.137
VBIH6 − DABC*_RCT(−0.0671, 0.0252)0.371
Table 5. Best-known solutions.
Table 5. Best-known solutions.
BKS IVLSVBIH1VBIH2VBIH3VBIH4VBIH5VBIH6DABC_RCTDABC*_RCT
Problem Set 20 × 5
14953149531495314953149531495314953149531495314953
16343163491634316343163431634316343163431634316343
14297142971429714297142971429714297142971429714297
16483164831648316483164831648316483164831648316483
14212142121421214212142121421214212142121421214212
14624146241462414624146241462414624146241462414624
14936149381493614936149361493614936149361493814938
15193152401519315193151931519315193151931519315193
15544155441554415544155441554415544155441554415544
14392143921439214392143921439214392143921439214392
Problem Set 20 × 10
22358225372235822358223582235822358223582235822358
23881238812388123881238812388123881238812388123881
20873208732087320873208732087320873208732087320873
19916200201991619916199161991619916199161991619916
20196201962019620196201962019620196201962019620196
20126201262012620126201262012620126201262012620126
19471194711947119471194711947119471194711947119471
21330213692133021330213302133021330213302133021330
21585215852158521585215852158521585215852158521585
22582225822258222582225822258222582225822258222582
Problem Set 20 × 20
34683346833468334683346833468334683346833468334683
32855328553285532855328553285532855328553285532855
34825348253482534825348253482534825348253482534825
33006330063300633006330063300633006330063300633006
35328353283532835328353283532835328353283532835328
33720337203372033720337203372033720337203372033720
33992339923399233992339923399233992339923399233992
33388333883338833388333883338833388333883338833388
34798347983479834798347983479834798347983479834798
33174331743317433174331743317433174331743317433174
Problem Set 50 × 5
72672727587267272696726727269672758728277313572768
78140787077825478332781817818178181782847832778295
72913732117309673224731017322472913729947291373224
77399777117751377571775477758677547775477758277607
78353787057862778579785447836378511785117876778620
75402754027566175606754757559375402755147612275615
73842743227395274202739527389073952738917395473890
73442739647394573442738347344273549735497385873442
70871713607090570871708717088370883708837109671105
78729792717877378729787297880778729787297877379093
Problem Set 50 × 10
99674100508100373996741002991000599972110041099900100325
95608956699590796157956699604795876958769656596367
91791927609195692090917919209092090922769258892524
98454987679847598689984549845498507985079869298576
98164982869824398164982309816498228982289861098228
97246978269763797779974319753097558973339802997625
9995310014210003099965999659995399971100116100440100584
98027982319814998271984769843698543982709872398521
96708972489670896996969969670897142967089697897634
98019990129831698316983169831698053980539831698362
Problem Set 50 × 20
136865137240136881137075137075136968137005137005136958137161
129958130333130115129975130292130244130248129975130176130303
127617128784127617127957127617128073127617127617128033128393
131889132452132270132169132270132103131943131943132283132169
130967131159130979131217131233130967131196130979131351131064
131760132121131985131760131760131929131926131921131593132007
134217134857134222134534134572134534134726134451134715134636
132990133502132990133210133210133210133309133309133526133210
132599132819132757132715132901132757132599132599132599133120
135710136166135985136162136224136363136248136146136483136473
Problem Set 100 × 5
288332289888288446289216288765288854290346288904289463288807
280491282897281066280743280853280073280873280929282857282563
276228277904275863276229276322277751276589276695278117277968
259596262968261462261867261601261985261715261231263990261478
273086275571274651274335274451274690274005274817274804275092
267381271534269418267899270406269506270408269194268899269356
274744277150275884277009277342276656275491276609277163277535
269689272776271187270939270945270774270668271001271916271719
284816286683285308285238284901284652284952284755287494284856
282005282659282969283292282814282366282367282719283596283939
Problem Set 100 × 10
354083357361354586355794356308354892353321354624354570356911
333379335775335738336636335905335268336469336601337164336403
343957346543344337345157345524345069344824345654344863345889
359259362441361621363410360537361230360709359680361328364095
338537339455339573339976338941341468341261340741340771341207
327254331594329327328482330769328075328693329377330296329454
335366339300338219337094339001338948338091338091337997338643
343174346305345286344609344905346013345217343843344417344886
344563357006354676357664356781356050355165354659356177356628
347845349966349546348910350290349351350879350580350674350693
Problem Set 100 × 20
425224427753427810426032427688426582427549426845427899426093
435289438146436000436495437478436409437908436205439020437380
430634431419432953433663431713434502431905432067435222434241
432314436203435708435999435001437256435401435880437725438501
426405429524428737429044428845430388428200429321429886429472
430308434216432099431680432345433041432139434523434105431202
436642440171440174441664438725441037437488439062440081442024
440930445900443867445170445219443812443648444357444299445169
432876435264434452435075434655433631434701434806437318435536
437286440819440918438439440992438621440484438530443779439693
Problem Set 200 × 10
1281633128129212860771283314128194712814011280745128244512858191281919
1283164127991312852681279947128079912805481280432128188612792401280107
1277933128041212819051279882128222812824471281843128470012828121276690
1271502127586512804171280027127471112739791274071127741412788331280871
1275901128257012761101286907127912612805111275710127982312779541285519
1251213125211012584631248655125253612547241252145124805812580541244667
1304158130760213035451311626130554113052011306954130258513096721309810
1298900129659113011841303103129750112958441302459129930212964691302829
1277801127088312780231273946127011812771451278259127764612788081272519
1273794128147212794521284374128168012788871282278128276312807991283774
Problem Set 200 × 20
1499623150530115094091506809150386115082651516354151139315120331508941
1541253153820815401311531179153898915386261538036153697115388901534481
1546279154691515539631557771155023715535551558080155844515599081558470
1540822154296115378521545112154447215444291548607154706215414471544097
1514600151569215146091520799151547015178991520051152137515189891520058
1528885153500615339071532007153511415343061533721153335715433801528532
1532090153582215342431532903153690915344231540592154020015391441529204
1543229153788515405391542855154022115389061541537154215115431591543637
1524293152277115177011516868152295815250681524214151955815245501514130
1535329153349215289951534456153483015355041538711153624515400381534682
Problem Set 500 × 20
8719682870610287019768693435870550286913978704588872056587307778702888
8849228882369888047008813687882557788167908820512882508489082208814543
8789777874514587461298742781872891887504218759822874682688119438739388
8828454879132588077118793936879308887952428807649880325488624268795162
8796337873501487223948741122873698887551378781374875633287915168774397
8837577880493888218808793126880339988203318809748882419288702938791898
8729909871804287341688734722871932487370338750115874841188024638733839
8800506876604487561658773136877230887740528761218878798887963758772084
8782791873986487510278727721874374187439408761953874753387991048773353
8849551879167188024208780952878859487966228810047881860688789958805877
Problem Set 200 × 5
1071652107305510727601076925107188910730651073348107117010717051070790
1026640102651010214331025826102531010235151028051102443210194311025138
1059120106472810627141064025106424410609821065879106456910627591061449
1044074104842010512251042391104835010492981042292104706610482121044776
1064274106401910641751060847106464910610811060213106206910604201062216
1021482102489310275781029903102540910276701029104103062610265611029891
1082018108110710799451082921108103310817801083320108446410836681081968
1043921104749010486091050141104569110481501051041104832110509361049380
1057482105767310584381056355105828110583691056063105570510581991059175
1037496104371910437771039727104231010456281039183104326610369381039695
Problem Set 500 × 5
6389122637532563815176371100637111763667626397170638750664035896369864
6415066641346964337136392620640036163968076432279643655264210486392856
6460745642677164265916435399643488264346286440953645404764785076430821
6334201630385963232366305175630608963181466337465633455563640656318682
6373873638316463926406369007638377463558016408507641373263973516369219
6282522627545262814286283594627793262743626292695630182663025076283635
6244926626213662629576262423626008962614446285376627374362616206258574
6352627636728163955446370417637056663773676376438639236563507556366156
6328390633596763424256336154633522063431546342796635936563546176330549
6309180630963963145916297997630722463007146320912632314863468286307074
Problem Set 500 × 10
7552404751415975348547522904751984675232597533739754993475778697541901
7665025763238276333777649655763556176222437642501765201076585417643615
7626599759003775998507580415758820275907807622675762244576524977603273
7626405761838576009967633161761905876153087645654762370676356797635154
7479900748402574680877472600746870374784467464923749673875045747476013
7537299754807175460717563456755127375510397572887756657475861507562912
7510712750592175026937490848750409674825957478959751466675346497491561
7562013757790275992637598437758803675989477599345763552576077377599718
7550242753821975371187533874753912775477307577922757422775814867536618
7549596757715675963517588889758075075628987611269758968376628237594287
Bold: better results, Bold Italic: equal results.