# An Enhanced Discrete Artificial Bee Colony Algorithm to Minimize the Total Flow Time in Permutation Flow Shop Scheduling with Limited Buffers

Authors: Guanlong Deng; Hongyong Yang; Shuning Zhang
Journal: Mathematical Problems in Engineering
 (2016)

---

## Abstract

This paper presents an enhanced discrete artificial bee colony algorithm for minimizing the total flow time in the flow shop scheduling problem with buffer capacity. First, the solution in the algorithm is represented as discrete job permutation to directly convert to active schedule. Then, we present a simple and effective scheme called best insertion for the employed bee and onlooker bee and introduce a combined local search exploring both insertion and swap neighborhood. To validate the performance of the presented algorithm, a computational campaign is carried out on the Taillard benchmark instances, and computations and comparisons show that the proposed algorithm is not only capable of solving the benchmark set better than the existing discrete differential evolution algorithm and iterated greedy algorithm, but also capable of performing better than two recently proposed discrete artificial bee colony algorithms.


---

## Body

## 1. Introduction

In the scope of scheduling problem, the permutation flow shop scheduling problem (PFSP) is one of the most important and studied issues because of its theoretical complexity and practical application. The traditional permutation flow shop model is not concerned with the capacity for buffer between two consecutive machines, and once its processing on a machine is finished, a job waits till the next machine is available to process it. However, in real production environments, the buffers are usually limited. Examples lie in the petrochemical processing industries and cell manufacturing [1]. In such a scheduling problem, after finishing its operation on a machine, if the next machine is not available, a job is allowed to store in a buffer only if the buffers are not full. If the buffers are full, the job must wait on the incumbent machine, which may make the machine unable to process other jobs. One special case in the permutation flow shop scheduling problem with limited buffers (LBPFSP) is with no buffer, and the problem is called the blocking flow shop scheduling problem (BPFSP). The BPFSP has gained much attention in the past decades [2, 3] and its strong NP-hard characteristics were validated for the case with more than two machines [4]. Besides, the LBPFSP is also strongly NP-hard even for only two machines [5].A great amount of research work has been carried out for the BPFSP. Many heuristics were introduced or proposed for the problem [6–9], but they are not good enough, especially for problem instance with big size. In recent years, lots of sophisticated metaheuristics have been developed for the problem. For the makespan criterion, the developed metaheuristics include genetic algorithm (GA) [10], tabu search (TS) algorithm [11], hybrid discrete differential evolution (HDDE) algorithm [12], iterated greedy (IG) algorithm by [2], hybrid modified global-best harmony search (hmgHS) algorithm [13], and variable neighborhood search (VNS) [14]. Recently, some researchers also proposed algorithms to minimize the total flow time (TFT) of the BPFSP. Wang et al. [15] developed an hmgHS algorithm and Deng et al. [16] put forward a discrete artificial bee (DABC) algorithm.As a more general problem, the LBPFSP received increasing attention in recent years. An early overview article was provided by Leisten [7], and the article concluded that the NEH heuristic is competitive. Smutnicki [17] presented a TS algorithm for the case with two machines, and the TS algorithm was later generalized to the case with more machines by Nowicki [18]. Also, an effective TS algorithm was developed by Brucker et al. [19]. Later, a hybrid genetic algorithm (HGA) by Wang et al. [20] was shown to outperform the TS algorithm. Further, Liu et al. [21] presented a hybrid particle swarm optimization (HPSO) algorithm that yielded better results than HGA. Qian et al. [22] investigated a hybrid differential evolution (HDE) algorithm for not only the finite buffer case but also the blocking and infinite buffer case. An immune based approach (IA) was developed by Hsieh et al. [23] and its superiority over the HGA was asserted. Recently, in two papers, Pan et al. [24, 25] proposed two metaheuristics, chaotic harmony search (CHS) and HDDE, and showed their superiority over the HGA and HPSO algorithm, respectively. More recent work was developed by Zhao et al. [26] and Moslehi and Khorasanian [27]. The former proposed an improved PSO algorithm while the latter presented a hybrid variable neighborhood search (HVNS) hybridizing variable neighborhood search and simulated annealing algorithm. In the HVNS algorithm, a speed-up method was developed for several kinds of local search methods.In the past decades, a bunch of metaheuristics based on swarm intelligence has been proposed and applied to scheduling problems [28, 29]. Among them, the artificial bee colony (ABC) algorithm [30–33] performed well in continuous function optimization, and Pan et al. [34] firstly proposed a discrete version of the ABC (DABC) algorithm for the lot-streaming flow shop scheduling. Then, Tasgetiren et al. [35] and Deng et al. [16] also developed a DABC algorithm for the PFSP and BPFSP, respectively. However, to the best of our knowledge, there is no published study on solving the LBPFSP using this algorithm. As for the LBPFSP, the existing work all focused on the makespan minimization, and no research work has been done with the TFT criterion, despite the prominence of the TFT criterion. Therefore, this paper aims to present a simple and effective DABC algorithm for the LBPFSP with the TFT criterion, which is not a well-studied scheduling problem. The developed DABC algorithm is based on the hybridization of ABC algorithm paradigm and local search methodology, and its performance is investigated by extensive experiments.The rest of the paper is organized as follows. In Section2, the considered problem with the TFT criterion is introduced and formulated. The proposed DABC algorithm is then presented as a simple and effective method for the TFT criterion case in Section 3. Section 4 provides the parameter calibration and performance investigation based on computational experiments. Finally, Section 5 gives out the conclusions and future work of the paper.


## 2. Problem Formulation

In the LBPFSP with the TFT criterion, there are a set ofn jobs N
=
{
1,2
,
…
,
n
} and a set of m machines M
=
{
M
1
,
M
2
,
…
,
M
m
}. The operation of job j
(
j
=
1,2
,
…
,
n
) on machine M
i  (
i
=
1,2
,
…
,
m
) requires a nonnegative time given as p
i
j. Every job has to be processed consecutively from the first machine M
1 to the last machine M
m. The following traditional flow shop assumptions apply. (
1
) All jobs are independent and available for processing at time zero. (
2
) At any time, each job is being processed at most on one machine and each machine is processing at most one job. (
3
) There is no breaking down in machines. (
4
) An operation can not be interrupted or split. (
5
) The setup and release times are ignored. Besides, the “permutation” requires that the job processing sequence must be the same on all machines. Between two consecutive machines M
i and M
i
+
1, there is a buffer with the capacity equal to B
i
(
B
i
≥
0, i
=
1,2
,
…
,
m
-
1
). Therefore, the number of stored jobs between two consecutive machines is at most B
i. If no buffer exists and the downstream machine is busy, a completed job has to stay on the current machine and thus may block it. The TFT is defined as ∑
j
=
1
n
C
j, where C
j is the time when job j is finished. The objective is to minimize the TFT.Since the TFT belongs to regular optimality criteria, there exists at least one active schedule that is optimal, and thus each schedule can be represented as a job permutationπ
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
), where the job is processed as early as possible with respect to the given sequence in π. Let TFT
(
π
) denote the total flow time of π and let d
π
(
j
)
,
i denote the leaving time of job π
(
j
) from machine M
i. The values of d
π
(
j
)
,
i can be calculated as follows [25]:(1)
d
π
1
,
1
=
p
π
1
,
1
,
d
π
1
,
i
=
d
π
1
,
i
-
1
+
p
π
1
,
i
,
i
=
2
,
…
,
m
,
d
π
j
,
1
=
d
π
j
-
1
,
1
+
p
π
j
,
1
,
j
=
2
,
…
,
B
1
+
1
,
d
π
j
,
i
=
max
⁡
d
π
j
-
1
,
i
,
d
π
j
,
i
-
1
+
p
π
j
,
i
,
j
=
2
,
…
,
B
i
+
1
,
i
=
2
,
…
,
m
-
1
,
d
π
j
,
1
=
max
⁡
d
π
j
-
1
,
1
+
p
π
j
,
1
,
d
π
j
-
B
1
-
1
,
2
,
j
>
B
1
+
1
,
d
π
j
,
i
=
max
⁡
max
⁡
d
π
j
-
1
,
i
,
d
π
j
,
i
-
1
+
p
π
j
,
i
,
d
π
j
-
B
i
-
1
,
i
+
1
,
j
>
B
i
+
1
,
i
=
2
,
…
,
m
-
1
,
d
π
j
,
m
=
max
⁡
d
π
j
-
1
,
m
,
d
π
j
,
m
-
1
+
p
π
j
,
m
,
j
=
2
,
…
,
n
.Using the above recursion, we can calculate the TFT with time complexityO
(
m
n
):(2)TFTπ=∑j=1ndπj,m.If all permutations are denoted as setΠ, then we have to find a permutation π
∗ in Π such that(3)TFTπ∗≤TFTπ∀π∈Π.Clearly, ifB
i
=
0, then the problem is the same as BPFSP. If B
i
≥
n
-
1, then the problem can be treated as PFSP. Due to the extensive work carried out for the BPFSP and PFSP, we will investigate the not-well-studied case; namely, the problem with the buffer size is finite.


## 3. Discrete Artificial Bee Colony Algorithm

According to the framework of the ABC algorithm, the algorithm includes three kinds of bees, namely, employed bee, onlooker bee, and scout bee. The solutions (called food sources) of the algorithm form a population with size NP. After initialization of the population, the algorithm goes into an iteration till the stopping criterion is satisfied. In the iteration, the algorithm sends first each employed bee, then each onlooker bee, and finally each scout bee to explore food sources. Since the ABC algorithm is originally proposed for continuous function optimization, it needs the conversion from real domain to discrete domain if the continuous coding solution is used. Due to the discrete characteristic of the considered problem, this paper uses job permutation as solution representation and puts forward a discrete ABC algorithm. To make the algorithm simple yet effective, we adopt the idea of iterated greedy (IG) algorithm of Ruiz and Stützle [36]. The IG algorithm mainly includes two important procedures. First, the destruction and construction procedure produce a new solution by perturbing the incumbent solution which is usually a local optimum. By iteratively searching the insertion neighborhood of the new solution, a local search is imposed on the new solution. These two procedures are modified or improved in the new DABC algorithm to design the operators of the employed, onlooker, and scout bees. All the elements are elaborated in the following subsections.


### 3.1. Initialization

As mentioned above, the DABC algorithm consists of NP food sources, where NP is a parameter controlling population size. For each food source, we need to generate a job sequenceπ
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
). The NEH heuristic and its variants are developed to construct the initial population with both quality and diversity. Wang et al. [15] pointed out that if the jobs are sequenced in increasing order rather than decreasing order in NEH, the obtained heuristic performs better than NEH heuristic for BPFSP with the TFT criterion. They denoted the variant as NEH_WPT heuristic. Besides, if the jobs are sequenced in random order in NEH, the obtained heuristic is a randomized heuristic, and it also works well according to our pilot experiments. We denote this randomized heuristic NEH_RAN. In our proposed algorithm, the solutions generated by both the NEH and NEH_WPT heuristics are included in the initial population, and the remaining NP-2 solutions of the initial population are generated by the NEH_RAN heuristic. Such an initialization scheme gives a guarantee of the population with good quality and diversity.


### 3.2. Employed Bee

For each solution in the population, the employed bee is firstly applied. Thus there are also NP employed bees. In the employed bee phase, a procedure, bestinsert, is presented to find a neighboring food source from the incumbent food source.Suppose that a permutation is denoted asπ
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
) and s
=
π
(
j
) is a job with position index j. By inserting job s into kth (k
∈
{
1
,
…
,
n
}
∖
{
j
}) position, we will get a permutation ω
(
s
,
k
). Let π
binsert
s denote the permutation resulting in the minimum objective value among all ω
(
s
,
k
) permutations. The bestinsert procedure is illustrated in Algorithm 1.Algorithm 1:Bestinsert procedure.
(1) choosed unrepeated jobs J
1
,
…
,
J
d randomly and let IL = J
1
,
…
,
J
d
(2)while (IL is not empty)
(3)  take out the front jobs from IL and delete it from IL
(4)j
= the position index of job s in π
(5)W
=
⌀
(6)for
k = 1 to j
-
1
(7)   addω
(
s
,
k
) into W
(8)endfor
(9)for
k
=
j
+
1 to n
(10)    addω
(
s
,
k
) into W
(11)endfor
(12)π
b
i
n
s
e
r
t
s = the best permutation in W
(13)π
=
π
b
i
n
s
e
r
t
s
(14)endwhileThe bestinsert procedure is designed as a perturbation operator to escape from local optima. The idea behind the bestinsert procedure is that making several compulsory insert moves would result in a solution that is usually different from but keeps probably the good characteristics of the incumbent solution. The setting of parameterd determines the degree of perturbation.Each employed bee employs the bestinsert procedure to generate a new food source. This generated food source is not directly put into the population but used by its corresponding onlooker bee.


### 3.3. Onlooker Bee

Before describing the design of the onlooker bee phase, we introduce several local search methods and present the combined local search.For the PFSP, most of the excellent local search methods consider the insertion neighborhood. The superiority of this neighborhood structure has been shown in lots of papers, such as [36–41]. In the insertion-based local search methods embedded in IG algorithms by Ruiz and Stützle [36], a job s is randomly chosen, and its π
binsert
s with respect to the incumbent solution π is then identified. If the solution π
binsert
s is better than the incumbent solution, the incumbent solution is replaced. The above process is repeated for all n jobs, which means that s is randomly and unrepeated chosen for n times. Furthermore, once the incumbent solution is updated for a job’s process, the processes of all n jobs need to be performed. The local search terminates when no improvement occurs for the processes of all n jobs. Pan et al. [39] improved this local search and presented the referenced local search (RLS). In RLS, jobs to be inserted are selected not randomly but according to the precedence of a referenced solution. Besides, the local search is optimized and the redundant process of finding π
binsert
s may be avoided. Similarly, Deng and Gu [40] also improved this local search but used a random order in which jobs are to be inserted. Their insertion-based local search (ILS) is shown in Algorithm 2.Algorithm 2:Insertion-based local search.
(1)π
D = a permutation generated randomly
(2)i
=
0
,
h
=
1
(3)while (i
<
n)
(4)  lets
=
π
D
(
h
)
(5)j = the position index of job s in π
(6)W
=
⌀
(7)for
k
=
1 to j
-
1
(8)   addω
(
s
,
k
) into W
(9)endfor
(10)for
k
=
j
+
1 to n
(11)   addω
(
s
,
k
) into W
(12)endfor
(13)π
b
i
n
s
e
r
t
s = the best permutation in W
(14)if (π
b
i
n
s
e
r
t
s is better than π)
(15)π
=
π
b
i
n
s
e
r
t
s
(16)i
=
1
(17)else
(18)i
=
i
+
1
(19)endif
(20)h
=
(
h
+
1
) % n
(21)endwhileIt can be seen from Algorithm2 that the job s to be inserted is chosen according to a random order π
D, and the procedure terminates once the process of finding π
binsert
s causes no improvement of π for consecutive n times. The effectiveness of the ILS inspired us to present a swap-based local search (SLS) with homogeneous structure. The SLS uses the swap neighborhood, and π
bswap
s is defined like π
binsert
s. Let s
=
π
(
j
) be a job scheduled in π
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
) and let v
(
s
,
k
) denote the sequence generated by swapping job s with the job occupying kth (k
∈
{
1
,
…
,
n
}
∖
{
j
}) position of π. π
bswap
s is the permutation resulting in the minimum objective value among all v
(
s
,
k
) permutations. The procedure of SLS is illustrated in Algorithm 3.Algorithm 3:Swap-based local search.
(1)π
D = a permutation generated randomly
(2)i
=
0
,
h
=
1
(3)while (i
<
n)
(4)  lets
=
π
D
(
h
)
(5)j = the position index of job s in π
(6)W
=
⌀
(7)for
k
=
1 to j
-
1
(8)   addv
(
s
,
k
) into W
(9)endfor
(10)for
k
=
j
+
1 to n
(11)   addv
(
s
,
k
) into W
(12)endfor
(13)π
b
s
w
a
p
s = the best permutation in W
(14)if (π
b
s
w
a
p
s is better than π)
(15)π
=
π
b
s
w
a
p
s
(16)i
=
1
(17)else
(18)i
=
i
+
1
(19)endif
(20)h
=
(
h
+
1
) % n
(21)endwhileIt should be pointed out that there is a possibility that a local optimum provided by ILS is not a local optimum when SLS is applied. So, we present the combined local search (CLS) by applying ILS and SLS iteratively till a local optimum is reached. The procedure is given in Algorithm4.Algorithm 4:Combined local search.
(1) apply ILS toπ
(2)while (true)
(3)  apply SLS toπ
(4)if (π is not improved during the previous Step)
(5)   break
(6)endif
(7)  apply ILS toπ
(8)if (π is not improved during the previous Step)
(9)   break
(10)endif
(11)endwhileThe number of onlooker bees is also NP. The onlooker bee applies the CLS to the food source returned by the employed bee. If the solution returned by CLS is not worse than the corresponding food source in the population, the corresponding food source in the population is replaced, or else it does not change. Note that the NP food sources in the population and the NP onlooker bees correspond one to one, which means whetherith food source is updated only depends on the solution found by ith onlooker bee. Setting the number of onlooker bees as NP can keep the parallel paradigm of the algorithm and benefit the depth and breadth of the algorithm’s search. Additionally, it can decrease the number of the algorithm’s parameters to be calibrated.


### 3.4. Scout Bee

There are two choices for a scout bee. It can either generate a food source randomly or produce a food source based on the best solutionπ
b. The latter tends to be more effective since the best solution in the current population often maintains better characteristics than others and the solution region around it could be more promising than others. Therefore, in the proposed DABC algorithm, the scout bee is designed to produce a food source by performing the bestinsert procedure and the ILS on the best solution π
b. First, the bestinsert procedure with parameter d
s is performed on π
b and generates a new food source, and then the new food source is further searched by the ILS. The finally obtained food source by the scout bee is put in the population through a tournament selection. The tournament selection randomly chooses two solutions in the population, and the worse one is replaced with the considered food source. For simplicity of the parameter setting, the number of the onlooker bees is set to 0.1NP.


### 3.5. Proposition of the DABC Algorithm

Since the details of all components of the DABC algorithm have been given out, the whole computational procedure is outlined in Algorithm5. Such an algorithm is expected to solve the LBPFSP with the TFT criterion effectively and efficiently.Algorithm 5:Procedure of the DABC algorithm.
(1) set parameters NP,d, ds
(2) generate the initial population
(3)π
b = the best solution in the population
(4)while (not termination)
(5)for (each employed bee)
(6)   apply bestinsert to its solution in the population
(7)endfor
(8)for (each onlooker bee)
(9)   apply CLS to the food source found by its employed bee
(10)    updateπ
b if possible
(11)endfor
(12)for (each scout bee)
(13)   produce a food source based onπ
b
(14)   put the food source in the population by tournament selection
(15)   updateπ
b if possible
(16)endfor
(17)endwhile


## 3.1. Initialization

As mentioned above, the DABC algorithm consists of NP food sources, where NP is a parameter controlling population size. For each food source, we need to generate a job sequenceπ
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
). The NEH heuristic and its variants are developed to construct the initial population with both quality and diversity. Wang et al. [15] pointed out that if the jobs are sequenced in increasing order rather than decreasing order in NEH, the obtained heuristic performs better than NEH heuristic for BPFSP with the TFT criterion. They denoted the variant as NEH_WPT heuristic. Besides, if the jobs are sequenced in random order in NEH, the obtained heuristic is a randomized heuristic, and it also works well according to our pilot experiments. We denote this randomized heuristic NEH_RAN. In our proposed algorithm, the solutions generated by both the NEH and NEH_WPT heuristics are included in the initial population, and the remaining NP-2 solutions of the initial population are generated by the NEH_RAN heuristic. Such an initialization scheme gives a guarantee of the population with good quality and diversity.


## 3.2. Employed Bee

For each solution in the population, the employed bee is firstly applied. Thus there are also NP employed bees. In the employed bee phase, a procedure, bestinsert, is presented to find a neighboring food source from the incumbent food source.Suppose that a permutation is denoted asπ
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
) and s
=
π
(
j
) is a job with position index j. By inserting job s into kth (k
∈
{
1
,
…
,
n
}
∖
{
j
}) position, we will get a permutation ω
(
s
,
k
). Let π
binsert
s denote the permutation resulting in the minimum objective value among all ω
(
s
,
k
) permutations. The bestinsert procedure is illustrated in Algorithm 1.Algorithm 1:Bestinsert procedure.
(1) choosed unrepeated jobs J
1
,
…
,
J
d randomly and let IL = J
1
,
…
,
J
d
(2)while (IL is not empty)
(3)  take out the front jobs from IL and delete it from IL
(4)j
= the position index of job s in π
(5)W
=
⌀
(6)for
k = 1 to j
-
1
(7)   addω
(
s
,
k
) into W
(8)endfor
(9)for
k
=
j
+
1 to n
(10)    addω
(
s
,
k
) into W
(11)endfor
(12)π
b
i
n
s
e
r
t
s = the best permutation in W
(13)π
=
π
b
i
n
s
e
r
t
s
(14)endwhileThe bestinsert procedure is designed as a perturbation operator to escape from local optima. The idea behind the bestinsert procedure is that making several compulsory insert moves would result in a solution that is usually different from but keeps probably the good characteristics of the incumbent solution. The setting of parameterd determines the degree of perturbation.Each employed bee employs the bestinsert procedure to generate a new food source. This generated food source is not directly put into the population but used by its corresponding onlooker bee.


## 3.3. Onlooker Bee

Before describing the design of the onlooker bee phase, we introduce several local search methods and present the combined local search.For the PFSP, most of the excellent local search methods consider the insertion neighborhood. The superiority of this neighborhood structure has been shown in lots of papers, such as [36–41]. In the insertion-based local search methods embedded in IG algorithms by Ruiz and Stützle [36], a job s is randomly chosen, and its π
binsert
s with respect to the incumbent solution π is then identified. If the solution π
binsert
s is better than the incumbent solution, the incumbent solution is replaced. The above process is repeated for all n jobs, which means that s is randomly and unrepeated chosen for n times. Furthermore, once the incumbent solution is updated for a job’s process, the processes of all n jobs need to be performed. The local search terminates when no improvement occurs for the processes of all n jobs. Pan et al. [39] improved this local search and presented the referenced local search (RLS). In RLS, jobs to be inserted are selected not randomly but according to the precedence of a referenced solution. Besides, the local search is optimized and the redundant process of finding π
binsert
s may be avoided. Similarly, Deng and Gu [40] also improved this local search but used a random order in which jobs are to be inserted. Their insertion-based local search (ILS) is shown in Algorithm 2.Algorithm 2:Insertion-based local search.
(1)π
D = a permutation generated randomly
(2)i
=
0
,
h
=
1
(3)while (i
<
n)
(4)  lets
=
π
D
(
h
)
(5)j = the position index of job s in π
(6)W
=
⌀
(7)for
k
=
1 to j
-
1
(8)   addω
(
s
,
k
) into W
(9)endfor
(10)for
k
=
j
+
1 to n
(11)   addω
(
s
,
k
) into W
(12)endfor
(13)π
b
i
n
s
e
r
t
s = the best permutation in W
(14)if (π
b
i
n
s
e
r
t
s is better than π)
(15)π
=
π
b
i
n
s
e
r
t
s
(16)i
=
1
(17)else
(18)i
=
i
+
1
(19)endif
(20)h
=
(
h
+
1
) % n
(21)endwhileIt can be seen from Algorithm2 that the job s to be inserted is chosen according to a random order π
D, and the procedure terminates once the process of finding π
binsert
s causes no improvement of π for consecutive n times. The effectiveness of the ILS inspired us to present a swap-based local search (SLS) with homogeneous structure. The SLS uses the swap neighborhood, and π
bswap
s is defined like π
binsert
s. Let s
=
π
(
j
) be a job scheduled in π
=
(
π
(
1
)
,
π
(
2
)
,
…
,
π
(
n
)
) and let v
(
s
,
k
) denote the sequence generated by swapping job s with the job occupying kth (k
∈
{
1
,
…
,
n
}
∖
{
j
}) position of π. π
bswap
s is the permutation resulting in the minimum objective value among all v
(
s
,
k
) permutations. The procedure of SLS is illustrated in Algorithm 3.Algorithm 3:Swap-based local search.
(1)π
D = a permutation generated randomly
(2)i
=
0
,
h
=
1
(3)while (i
<
n)
(4)  lets
=
π
D
(
h
)
(5)j = the position index of job s in π
(6)W
=
⌀
(7)for
k
=
1 to j
-
1
(8)   addv
(
s
,
k
) into W
(9)endfor
(10)for
k
=
j
+
1 to n
(11)   addv
(
s
,
k
) into W
(12)endfor
(13)π
b
s
w
a
p
s = the best permutation in W
(14)if (π
b
s
w
a
p
s is better than π)
(15)π
=
π
b
s
w
a
p
s
(16)i
=
1
(17)else
(18)i
=
i
+
1
(19)endif
(20)h
=
(
h
+
1
) % n
(21)endwhileIt should be pointed out that there is a possibility that a local optimum provided by ILS is not a local optimum when SLS is applied. So, we present the combined local search (CLS) by applying ILS and SLS iteratively till a local optimum is reached. The procedure is given in Algorithm4.Algorithm 4:Combined local search.
(1) apply ILS toπ
(2)while (true)
(3)  apply SLS toπ
(4)if (π is not improved during the previous Step)
(5)   break
(6)endif
(7)  apply ILS toπ
(8)if (π is not improved during the previous Step)
(9)   break
(10)endif
(11)endwhileThe number of onlooker bees is also NP. The onlooker bee applies the CLS to the food source returned by the employed bee. If the solution returned by CLS is not worse than the corresponding food source in the population, the corresponding food source in the population is replaced, or else it does not change. Note that the NP food sources in the population and the NP onlooker bees correspond one to one, which means whetherith food source is updated only depends on the solution found by ith onlooker bee. Setting the number of onlooker bees as NP can keep the parallel paradigm of the algorithm and benefit the depth and breadth of the algorithm’s search. Additionally, it can decrease the number of the algorithm’s parameters to be calibrated.


## 3.4. Scout Bee

There are two choices for a scout bee. It can either generate a food source randomly or produce a food source based on the best solutionπ
b. The latter tends to be more effective since the best solution in the current population often maintains better characteristics than others and the solution region around it could be more promising than others. Therefore, in the proposed DABC algorithm, the scout bee is designed to produce a food source by performing the bestinsert procedure and the ILS on the best solution π
b. First, the bestinsert procedure with parameter d
s is performed on π
b and generates a new food source, and then the new food source is further searched by the ILS. The finally obtained food source by the scout bee is put in the population through a tournament selection. The tournament selection randomly chooses two solutions in the population, and the worse one is replaced with the considered food source. For simplicity of the parameter setting, the number of the onlooker bees is set to 0.1NP.


## 3.5. Proposition of the DABC Algorithm

Since the details of all components of the DABC algorithm have been given out, the whole computational procedure is outlined in Algorithm5. Such an algorithm is expected to solve the LBPFSP with the TFT criterion effectively and efficiently.Algorithm 5:Procedure of the DABC algorithm.
(1) set parameters NP,d, ds
(2) generate the initial population
(3)π
b = the best solution in the population
(4)while (not termination)
(5)for (each employed bee)
(6)   apply bestinsert to its solution in the population
(7)endfor
(8)for (each onlooker bee)
(9)   apply CLS to the food source found by its employed bee
(10)    updateπ
b if possible
(11)endfor
(12)for (each scout bee)
(13)   produce a food source based onπ
b
(14)   put the food source in the population by tournament selection
(15)   updateπ
b if possible
(16)endfor
(17)endwhile


## 4. Computations and Comparisons

A large amount of computational experiments is carried out to test the performance of the presented DABC algorithm. The well-known Taillard benchmark instances with different sizes are used. In this paper, Taillard benchmark instances originally produced for the PFSP are treated as the LBPFSP with the TFT criterion. All the tested algorithms are programmed in C++ language and the running environment is a PC with Intel Core (TM) i5-2400 3.1 GHz processor. The relative percentage deviation (RPD) is calculated to indicate the amount of improvement over the reference solution. Consider(4)RPD=TFTA-TFTrefTFTref×100,where TFT
A is the TFT of the solution obtained by the tested algorithm A and TFT
ref is the TFT of the reference solution.The reference solutions are the best solutions in all of these computational experiments for all algorithms, and they are shown in the Appendix for all tested instances. Clearly, the lower the RPD value is, the better results the algorithm yields.


### 4.1. Algorithm Calibration

In this section, we carry out an experiment to calibrate the proposed DABC algorithm (denoted by DABC). Since the computational efforts of the CLS are usually more than that of the local search employing a single neighborhood structure and the CLS is performed for NP times in each generation of the DABC algorithm, we suggest that the parameter NP is not too large, especially when the allowed computational time of the algorithm is relatively less. For all computations of the DABC algorithm in this paper, we set NP to 10 and the stopping criterion is elapsed CPU time not less than3
n
2
m milliseconds. Setting this CPU time related to the instances size allows the algorithm more time to solve the larger size instances that are probably “harder.” In the calibration experiment, we perform a large Design of Experiments [42], and the following factors are tested: (
1
) the type of local search (LS), tested at three levels: the local search by Ruiz and Stützle [36] (denoted by LS_RS), ILS, and CLS; (
2
) the parameter d, tested at eight levels: 2–9; (
3
) the parameter d
s, tested at eight levels: 2–9. Nine instances, T
a
01
,
T
a
11
,
…
,
T
a
81, are selected from each problem group to avoid bias of the results, and the algorithm is run for 10 replications with each parameter configuration for each selected instance. For simplicity, they are treated as the LBPFSP with all buffers equal to one. In all, the multifactor experimental design yields 3 × 8 × 8 × 10 × 9 = 17280 results. With such a large data set, the Analysis of Variance (ANOVA) technique is introduced to draw a convincing conclusion of parameter calibration. The ANOVA results are shown in Table 1.Table 1
ANOVA results for the experiment on the calibration of DABC.
Source
Sum of squares
Df
Mean square
F value
p value
Main effects
A: LS
5.37
2
2.69
62.23
<0.0001
B:d
5.81
7
0.83
19.23
<0.0001
C:ds
0.37
7
0.053
1.23
0.2836
Interactions
AB
6.192
e
-
005
14
4.423
e
-
006
1.025
e
-
004
1.0000
AC
6.097
e
-
005
14
4.435
e
-
006
1.009
e
-
004
1.0000
BC
5.59
49
0.11
2.64
<0.0001It is concluded from Table1 that factor LS and factor d are statistically significant for the algorithm performance due to its p value less than 0.0001, while factor d
s is not statistically significant with a p value equal to 0.2836. Besides, we note that the interaction of parameters d and d
s is also significant, which is understandable since the employed bee phase is related to the scout bee phase.Furthermore, to illustrate the differences of algorithm performance with different parameter values, we reproduce the one-factor means plots with 95% Least Significant Difference (LSD) confidence intervals of the factors LS andd, shown in Figure 1. According to the statistical theory, it is seen from Figure 1 that, for the local search method, the proposed CLS is statistically better than ILS and ILS is statistically better than LS_RS. For the parameter d, the setting value 7 is statistically better than the setting values 2–6. As regards parameter d
s, the differences are small and its means plot is omitted for simplicity. Finally, we calibrate the DABC algorithm, using combined local search, as d
=
7 and d
s
=
4.Figure 1
Means plot with 95% LSD intervals for the type of local search and the parameterd of the DABC algorithm.


### 4.2. Computational Comparisons

In the comparisons with other algorithms from the literature, the proposed algorithm uses the calibrated parameter setting. To our knowledge, the LBPFSP with the TFT criterion has not been well studied, so we take four well-performed algorithms from the PFSP literature and adapt them for the considered problem in this paper. The algorithms selected for comparisons are the following:(
1
) the iterated greedy algorithm [36] (IG); (
2
) the hybrid discrete differential evolution [25] (HDDE) algorithm; (
3
) the discrete artificial bee colony algorithm [35] (DABC_T); and (
4
) the discrete artificial bee colony algorithm [16] (DABC_D). All the above compared algorithms are reimplemented for the considered problem and performed under the original algorithm’s parameter settings. Wang et al. [20] reported that when the buffer size is equal to 4, the problem is very close to the case with the buffers of infinite capacity. Therefore, here, all the five algorithms treat the problem with unitary buffer size B equal to 1, 2, 3, and 4. For each instance in all the 90 Taillard benchmark instances, each algorithm is run 10 times. In total, we have 5 × 4 × 90 × 10 = 18000 data points. The average relative percentage deviation (ARPD) values grouped in subsets of different sizes are summarized in Tables 2–5 for each buffer size, respectively.Table 2
ARPD of each algorithm on Taillard benchmark set (B
=
1).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.04
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.03
50
×
5
0.30
0.35
0.42
0.61
1.14
50
×
10
0.30
0.36
0.46
0.64
0.89
50
×
20
0.23
0.29
0.42
0.49
0.75
100
×
5
0.34
0.40
0.44
0.80
1.51
100
×
10
0.29
0.35
0.47
0.63
0.97
100
×
20
0.27
0.33
0.47
0.60
0.84
Overall mean
0.19
0.23
0.30
0.42
0.69Table 3
ARPD of each algorithm on Taillard benchmark set (B
=
2).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.02
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.19
0.24
0.30
0.34
0.47
50
×
10
0.21
0.27
0.36
0.49
0.72
50
×
20
0.23
0.29
0.41
0.47
0.66
100
×
5
0.18
0.23
0.33
0.49
0.88
100
×
10
0.32
0.38
0.48
0.67
0.97
100
×
20
0.33
0.39
0.51
0.58
0.86
Overall mean
0.16
0.20
0.26
0.34
0.52Table 4
ARPD of each algorithm on Taillard benchmark set (B
=
3).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.02
20
×
10
0.00
0.00
0.00
0.00
0.02
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.16
0.22
0.22
0.24
0.41
50
×
10
0.28
0.34
0.39
0.45
0.65
50
×
20
0.22
0.28
0.35
0.43
0.69
100
×
5
0.18
0.23
0.32
0.43
0.74
100
×
10
0.26
0.31
0.47
0.58
0.91
100
×
20
0.27
0.33
0.42
0.49
0.72
Overall mean
0.15
0.19
0.24
0.29
0.46Table 5
ARPD of each algorithm on Taillard benchmark set (B
=
4).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.05
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.13
0.17
0.24
0.29
0.43
50
×
10
0.27
0.32
0.34
0.44
0.67
50
×
20
0.23
0.28
0.38
0.50
0.61
100
×
5
0.12
0.17
0.28
0.41
0.63
100
×
10
0.28
0.33
0.40
0.55
0.84
100
×
20
0.29
0.34
0.45
0.57
0.85
Overall mean
0.15
0.18
0.23
0.31
0.46Since the five algorithms are all executed in the same computational environment with the same stopping criteria, the results are fully and completely comparable. Tables2–5 validate the superiority of the DABC algorithm over the other compared algorithms. The overall mean RPD values yielded by the DABC algorithm are 0.19, 0.16, 0.15, and 0.15 when buffer size is equal to 1, 2, 3, and 4, respectively, which are substantially lower than those (0.23, 0.20, 0.19, and 0.18) obtained by the DABC_D algorithm, those (0.30, 0.26, 0.24, and 0.23) obtained by the DABC_T algorithm, those (0.42, 0.34, 0.29, and 0.31) obtained by the HDDE algorithm, and those (0.69, 0.52, 0.46, and 0.46) obtained by the IG_RS algorithm. Furthermore, for each buffer size, the DABC algorithm has a lower ARPD value than all the other algorithms for each of the nine subsets except that, for the subsets with 20 jobs, the DABC, DABC_D, DABC_T, and HDDE algorithms generate the same ARPD value equal to zero.While the differences of the DABC algorithm and the other algorithms are quite clear from these tables, it is still necessary to perform some statistical tests on the RPD results in order to observe whether the differences in the ARPD values are indeed statistically significant. Therefore, we employ the 4500 data points for each buffer size and conduct an ANOVA. The one-factor means plots with 95% Least Significant Difference (LSD) confidence intervals of the factor algorithm are shown in Figure2.Figure 2
Means plot with 95% LSD intervals for different algorithms.
(a)
B
=
1
(b)
B
=
2
(c)
B
=
3
(d)
B
=
4From Figure2, it can be seen that although there are slight differences in the means plots for different buffer sizes, the same dominance relation between any two algorithms can be obtained. Specifically, the LSD intervals of any two algorithms are not overlapping, so we can conclude that the differences between any two algorithms are statistically significant. The statistical results also show that the DABC_D algorithm is better than the DABC_T algorithm, the DABC_T algorithm is better than the HDDE algorithm, and the HDDE algorithm is better than the IG_RS algorithm.Further, to illustrate the convergence characteristics of these algorithms, Figures3–6 illustrate several typical convergence curves of the algorithms, for instance, Ta80. The convergence curves show how the best found total flow time values descended as the CPU time elapses for each algorithm, and they reveal that in general the proposed DABC algorithm obtained a better solution than the DABC_D, DABC_T, HDDE, and IG_RS algorithms and its advantages become more and more impressive as the computational time elapses. After all, the convergence curves validate the superiority of the DABC algorithm over the DABC_D, DABC_T, HDDE, and IG_RS algorithms.Figure 3
The convergence curves for instance Ta80 (B
=
1).Figure 4
The convergence curves for instance Ta80 (B
=
2).Figure 5
The convergence curves for instance Ta80 (B
=
3).Figure 6
The convergence curves for instance Ta80 (B
=
4).


## 4.1. Algorithm Calibration

In this section, we carry out an experiment to calibrate the proposed DABC algorithm (denoted by DABC). Since the computational efforts of the CLS are usually more than that of the local search employing a single neighborhood structure and the CLS is performed for NP times in each generation of the DABC algorithm, we suggest that the parameter NP is not too large, especially when the allowed computational time of the algorithm is relatively less. For all computations of the DABC algorithm in this paper, we set NP to 10 and the stopping criterion is elapsed CPU time not less than3
n
2
m milliseconds. Setting this CPU time related to the instances size allows the algorithm more time to solve the larger size instances that are probably “harder.” In the calibration experiment, we perform a large Design of Experiments [42], and the following factors are tested: (
1
) the type of local search (LS), tested at three levels: the local search by Ruiz and Stützle [36] (denoted by LS_RS), ILS, and CLS; (
2
) the parameter d, tested at eight levels: 2–9; (
3
) the parameter d
s, tested at eight levels: 2–9. Nine instances, T
a
01
,
T
a
11
,
…
,
T
a
81, are selected from each problem group to avoid bias of the results, and the algorithm is run for 10 replications with each parameter configuration for each selected instance. For simplicity, they are treated as the LBPFSP with all buffers equal to one. In all, the multifactor experimental design yields 3 × 8 × 8 × 10 × 9 = 17280 results. With such a large data set, the Analysis of Variance (ANOVA) technique is introduced to draw a convincing conclusion of parameter calibration. The ANOVA results are shown in Table 1.Table 1
ANOVA results for the experiment on the calibration of DABC.
Source
Sum of squares
Df
Mean square
F value
p value
Main effects
A: LS
5.37
2
2.69
62.23
<0.0001
B:d
5.81
7
0.83
19.23
<0.0001
C:ds
0.37
7
0.053
1.23
0.2836
Interactions
AB
6.192
e
-
005
14
4.423
e
-
006
1.025
e
-
004
1.0000
AC
6.097
e
-
005
14
4.435
e
-
006
1.009
e
-
004
1.0000
BC
5.59
49
0.11
2.64
<0.0001It is concluded from Table1 that factor LS and factor d are statistically significant for the algorithm performance due to its p value less than 0.0001, while factor d
s is not statistically significant with a p value equal to 0.2836. Besides, we note that the interaction of parameters d and d
s is also significant, which is understandable since the employed bee phase is related to the scout bee phase.Furthermore, to illustrate the differences of algorithm performance with different parameter values, we reproduce the one-factor means plots with 95% Least Significant Difference (LSD) confidence intervals of the factors LS andd, shown in Figure 1. According to the statistical theory, it is seen from Figure 1 that, for the local search method, the proposed CLS is statistically better than ILS and ILS is statistically better than LS_RS. For the parameter d, the setting value 7 is statistically better than the setting values 2–6. As regards parameter d
s, the differences are small and its means plot is omitted for simplicity. Finally, we calibrate the DABC algorithm, using combined local search, as d
=
7 and d
s
=
4.Figure 1
Means plot with 95% LSD intervals for the type of local search and the parameterd of the DABC algorithm.


## 4.2. Computational Comparisons

In the comparisons with other algorithms from the literature, the proposed algorithm uses the calibrated parameter setting. To our knowledge, the LBPFSP with the TFT criterion has not been well studied, so we take four well-performed algorithms from the PFSP literature and adapt them for the considered problem in this paper. The algorithms selected for comparisons are the following:(
1
) the iterated greedy algorithm [36] (IG); (
2
) the hybrid discrete differential evolution [25] (HDDE) algorithm; (
3
) the discrete artificial bee colony algorithm [35] (DABC_T); and (
4
) the discrete artificial bee colony algorithm [16] (DABC_D). All the above compared algorithms are reimplemented for the considered problem and performed under the original algorithm’s parameter settings. Wang et al. [20] reported that when the buffer size is equal to 4, the problem is very close to the case with the buffers of infinite capacity. Therefore, here, all the five algorithms treat the problem with unitary buffer size B equal to 1, 2, 3, and 4. For each instance in all the 90 Taillard benchmark instances, each algorithm is run 10 times. In total, we have 5 × 4 × 90 × 10 = 18000 data points. The average relative percentage deviation (ARPD) values grouped in subsets of different sizes are summarized in Tables 2–5 for each buffer size, respectively.Table 2
ARPD of each algorithm on Taillard benchmark set (B
=
1).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.04
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.03
50
×
5
0.30
0.35
0.42
0.61
1.14
50
×
10
0.30
0.36
0.46
0.64
0.89
50
×
20
0.23
0.29
0.42
0.49
0.75
100
×
5
0.34
0.40
0.44
0.80
1.51
100
×
10
0.29
0.35
0.47
0.63
0.97
100
×
20
0.27
0.33
0.47
0.60
0.84
Overall mean
0.19
0.23
0.30
0.42
0.69Table 3
ARPD of each algorithm on Taillard benchmark set (B
=
2).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.02
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.19
0.24
0.30
0.34
0.47
50
×
10
0.21
0.27
0.36
0.49
0.72
50
×
20
0.23
0.29
0.41
0.47
0.66
100
×
5
0.18
0.23
0.33
0.49
0.88
100
×
10
0.32
0.38
0.48
0.67
0.97
100
×
20
0.33
0.39
0.51
0.58
0.86
Overall mean
0.16
0.20
0.26
0.34
0.52Table 4
ARPD of each algorithm on Taillard benchmark set (B
=
3).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.02
20
×
10
0.00
0.00
0.00
0.00
0.02
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.16
0.22
0.22
0.24
0.41
50
×
10
0.28
0.34
0.39
0.45
0.65
50
×
20
0.22
0.28
0.35
0.43
0.69
100
×
5
0.18
0.23
0.32
0.43
0.74
100
×
10
0.26
0.31
0.47
0.58
0.91
100
×
20
0.27
0.33
0.42
0.49
0.72
Overall mean
0.15
0.19
0.24
0.29
0.46Table 5
ARPD of each algorithm on Taillard benchmark set (B
=
4).
n
×
m
DABC
DABC_D
DABC_T
HDDE
IG_RS
2
0
×
5
0.00
0.00
0.00
0.00
0.05
20
×
10
0.00
0.00
0.00
0.00
0.03
20
×
20
0.00
0.00
0.00
0.00
0.02
50
×
5
0.13
0.17
0.24
0.29
0.43
50
×
10
0.27
0.32
0.34
0.44
0.67
50
×
20
0.23
0.28
0.38
0.50
0.61
100
×
5
0.12
0.17
0.28
0.41
0.63
100
×
10
0.28
0.33
0.40
0.55
0.84
100
×
20
0.29
0.34
0.45
0.57
0.85
Overall mean
0.15
0.18
0.23
0.31
0.46Since the five algorithms are all executed in the same computational environment with the same stopping criteria, the results are fully and completely comparable. Tables2–5 validate the superiority of the DABC algorithm over the other compared algorithms. The overall mean RPD values yielded by the DABC algorithm are 0.19, 0.16, 0.15, and 0.15 when buffer size is equal to 1, 2, 3, and 4, respectively, which are substantially lower than those (0.23, 0.20, 0.19, and 0.18) obtained by the DABC_D algorithm, those (0.30, 0.26, 0.24, and 0.23) obtained by the DABC_T algorithm, those (0.42, 0.34, 0.29, and 0.31) obtained by the HDDE algorithm, and those (0.69, 0.52, 0.46, and 0.46) obtained by the IG_RS algorithm. Furthermore, for each buffer size, the DABC algorithm has a lower ARPD value than all the other algorithms for each of the nine subsets except that, for the subsets with 20 jobs, the DABC, DABC_D, DABC_T, and HDDE algorithms generate the same ARPD value equal to zero.While the differences of the DABC algorithm and the other algorithms are quite clear from these tables, it is still necessary to perform some statistical tests on the RPD results in order to observe whether the differences in the ARPD values are indeed statistically significant. Therefore, we employ the 4500 data points for each buffer size and conduct an ANOVA. The one-factor means plots with 95% Least Significant Difference (LSD) confidence intervals of the factor algorithm are shown in Figure2.Figure 2
Means plot with 95% LSD intervals for different algorithms.
(a)
B
=
1
(b)
B
=
2
(c)
B
=
3
(d)
B
=
4From Figure2, it can be seen that although there are slight differences in the means plots for different buffer sizes, the same dominance relation between any two algorithms can be obtained. Specifically, the LSD intervals of any two algorithms are not overlapping, so we can conclude that the differences between any two algorithms are statistically significant. The statistical results also show that the DABC_D algorithm is better than the DABC_T algorithm, the DABC_T algorithm is better than the HDDE algorithm, and the HDDE algorithm is better than the IG_RS algorithm.Further, to illustrate the convergence characteristics of these algorithms, Figures3–6 illustrate several typical convergence curves of the algorithms, for instance, Ta80. The convergence curves show how the best found total flow time values descended as the CPU time elapses for each algorithm, and they reveal that in general the proposed DABC algorithm obtained a better solution than the DABC_D, DABC_T, HDDE, and IG_RS algorithms and its advantages become more and more impressive as the computational time elapses. After all, the convergence curves validate the superiority of the DABC algorithm over the DABC_D, DABC_T, HDDE, and IG_RS algorithms.Figure 3
The convergence curves for instance Ta80 (B
=
1).Figure 4
The convergence curves for instance Ta80 (B
=
2).Figure 5
The convergence curves for instance Ta80 (B
=
3).Figure 6
The convergence curves for instance Ta80 (B
=
4).


## 5. Conclusions

This paper proposes a discrete artificial bee colony (DABC) algorithm for solving the permutation flow shop scheduling problem with limited buffers with the total flow time minimization criterion. For solving this problem, the DABC algorithm uses discrete job permutation as food source and introduces the NEH heuristic and its variants to construct the initial population with consideration of both quality and diversity. Moreover, by presenting the best insertion procedure and the combined local search, we present the corresponding improved schemes for the employed bee, onlooker bee, and scout bee phases, respectively. The results of computational experiments and statistical analysis show that the proposed DABC algorithm not only is superior to the existing discrete differential evolution algorithm and iterated greedy algorithm but also performs better than two recently proposed discrete artificial bee colony algorithms. Besides, the DABC algorithm is technically feasible to apply in the practical production environment because of its structural simplicity as well as its high efficacy. In future, we will focus on adapting the DABC algorithm for multiobjective scheduling problems and stochastic scheduling models.



---

*Source: 7373617-2016-07-10.xml*