Applied Soft Computing Journal 100 (2021) 106946

Contents lists available at ScienceDirect

Applied Soft Computing Journal

journal homepage: www.elsevier.com/locate/asoc

A discrete artificial bee colony algorithm for the distributed

heterogeneous no-wait flowshop scheduling problem
∗
Li Haoran, Li Xinyu , Gao Liang
State Key Laboratory of Digital Manufacturing Equipment & Technology, Huazhong University of Science and Technology, Wuhan, 430074, China

article info a b s t r a c t

Article history: With the development of globalization, distributed manufacturing has become one of the main modes
Received 2 February 2020 of manufacturing. The situation in which a number of heterogeneous factories coproduce a batch
Received in revised form 22 November 2020 of jobs is ubiquitous in the field of distributed manufacturing. Compared with isomorphic factories,
Accepted 24 November 2020
heterogeneous factories bring further difficulty in assigning jobs to factories. This paper considers
Available online 30 November 2020
the heterogeneity between factories in distributed flow-shop scheduling for the first time. This paper
Keywords: addresses a distributed heterogeneous no-wait flowshop scheduling problem (DHNWFSP) to minimize
Distributed heterogeneous no-wait the makespan, where the factories have differences among them, including the number of machines,
flowshop scheduling machine technology, raw material supply, and transportation conditions. In this problem, the numbers
Artificial bee colony algorithm and types of machines in each factory are different, and this means that the jobs have to be processed
Neighborhood search operators
through different processing paths. To effectively solve this DHNWFSP, a discrete artificial bee colony
Variable Neighborhood descent algorithm
algorithm (DABC) is proposed. Firstly, to obtain a feasible neighborhood solution, four neighborhood
search operators based on the characteristics of this problem are presented to search neighborhoods
during the employed bee phase and onlooker bee phase. Then, a new method to accelerate the
evaluation of the obtained neighborhood is proposed to reduce the computation time. Moreover,
an efficient population update method is designed in the onlooker bee phase. Finally, a variable
neighborhood descent (VND) algorithm based on four local-search methods is embedded into the scout
bee phase to strengthen the local search ability of the overall algorithm. To validate the performance
of the proposed algorithm, a series of numerical experiments are executed for small- and large-scale
problems to compare the DABC with some state-of-art algorithms in terms of solving the DHNWFSP.
The results show that the proposed DABC obtains the highest-quality solutions.
© 2020 Elsevier B.V. All rights reserved.

1. Introduction the first machine starts to process a job, it has to be processed

through all machines of a factory. Therefore, the processing of
With the development of globalization, cooperative produc- a job will be delayed if pausing is necessary for satisfying the
tion between companies has become increasingly common. Dis- no-wait constraint. In reality, not all factories are identical in
tributed manufacturing has become one of the mainstream terms of distributed manufacturing. There are differences, such
modes of global production. Distributed manufacturing can help as the number of machines, machine technology, raw material
to improve product quality, reduce production costs, and min- supply and transportation conditions, between various factories.
imize management risk [1,2]. In addition, in real production Each factory may be different, and they may be located in dif-
environments, the no-wait flowshop model is widely used in the ferent places. Therefore, this paper studies a novel distributed
chemical processing industry [3], the food processing industry [4], no-wait flowshop scheduling problem (DNWFSP) called the dis-
the pharmaceutical industry [5], and the steel industry [6]. Mod- tributed heterogeneous no-wait flowshop scheduling problem
ern manufacturing systems such as just-in-time systems [7], flexi- (DHNWFSP). In this problem, the factories are in different ge-
ble manufacturing environments [8], and robotic cells [9] can also ographical locations, and the types and numbers of machines
be modeled as no-wait flowshop models. For example, in a steel in each factory may be different, but all factories can process
factory, the heated metal must be processed continuously so that all jobs. These factors lead to differences in processing. Jobs are
the temperature is maintained during processing. In a no-wait assigned to one of the different factories and go through different
flow shop, each job needs to be processed continuously. Once processing routes. The processing time of a job on a certain
machine in an individual factory is distinct. In reality, a batch of
∗ Corresponding author. jobs is assigned heterogeneous factories, but some factories have
E-mail address: [email protected] (X. Li). more advanced production devices than others, so jobs can be

https://doi.org/10.1016/j.asoc.2020.106946
1568-4946/© 2020 Elsevier B.V. All rights reserved.
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

finished earlier and with fewer processing steps in such factories. which are embedded into the VNS, VND, and random neighbor-
The study of the DHNWFSP narrows the gap between reality and hood structure (RNS), were proposed to enhance local searchabil-
theory. ity. For the DPFSP, many researchers have done much work in this
The heterogeneity of factories is essentially caused by process field. Furthermore, other researchers have studied other kinds of
flexibility. Process flexibility means that a processing feature can flow shop problems. Kuo and Shih also studied distributed no-idle
be achieved through multiple processing methods. For example, permutation flowshop scheduling problem (DNIPFSP) and pro-
the processing of the job related to a plane can be done in a posed an iterated reference greedy algorithm (IRG) [20]. They also
variety of ways. In a factory, the plane can be processed directly presented a self-tuning iterated greedy algorithm (SIG) for the
on a milling machine. In other factories, due to production capac- distributed hybrid flowshop scheduling problem with multipro-
ity limitations, the processing is performed on a boring machine cessor tasks (DHFSPMT) [21]. Zhang et al. studied the distributed
first, and then it is completed by the milling machine. Different blocking flowshop scheduling problem (DBFSP) [22]. Duan et al.
factories design different processes according to their abilities to proposed a discrete artificial bee colony algorithm (DABC) for
process the same product. Therefore, it is reasonable to consider solving the distributed lot-streaming flowshop scheduling prob-
the heterogeneity between factories in this paper, and this is lem (DLFSP) [23]. Pan et al. presented three constructive heuris-
manifested in the different numbers of machines and processing tics, two variable neighborhood search methods, and an iter-
times among the factories. ated greedy algorithm, for addressing the distributed assembly
The DHNWFSP can be seen as a general extension of the permutation flowshop scheduling problem (DAPFSP) [24].
permutation flowshop scheduling problem (PFSP). In the classic The DHNWFSP is difficult to solve by using exact methods
PFSP, N jobs are processed by m machines in the same order. because it is an NP hard problem. Therefore, some meta-heuristic
Considering multi-factory production, Naderi and Ruiz proposed a algorithms need to be examined. The artificial bee colony al-
novel PFSP called the distributed permutation flowshop schedul- gorithm (ABC) is an effective population-based meta-heuristic
ing problem (DPFSP) [10]. N jobs are assigned to f factories algorithm that was presented by Karaboga et al. [25]. The ABC
for processing. Each factory is identical, and each factory is a algorithm has been widely used in various optimization prob-
permutation flow-shop containing m machines. Therefore, this lems, such as, global optimization [26], dynamic clustering [27],
problem is converted to f PFSP for the purpose of optimizing the continuous optimization [28], transportation energy demand esti-
mation [29], structural damage detection [30], and feature selec-
scheduling objective. When the no-wait constraint is considered,
tion [31]. Similarly, the ABC algorithm is also widely used in shop
the DPFSP is extended to the DNWFSP, which was first proposed
scheduling problems such as flowshop [32,33], lot-streaming flow
by Shih and Kuo [11]. Therefore, the task of the DHNWFSP is to
shop [34], hybrid flowshop [35,36], job shop [37] and flexible
assign jobs to distinct factories and decide the job sequence in
job-shop [38]. However, there is little research on solving the dis-
each factory. A flowshop scheduling problem with more than two
tributed flowshop scheduling problem using the ABC algorithm.
machines is NP-hard [12], and the DPFSP, DNWFSP and DHNWFSP
Li et al. proposed using an improved artificial bee colony algo-
are also NP-hard problems.
rithm (IABC) for solving the DPFSP by considering the distance
The DPFSP is an extension of the FSP under the distributed
coefficient [39]. Motivated by this successful application of the
manufacturing model. At present, many researchers have stud-
ABC, this paper proposes a discrete artificial bee colony algo-
ied the DPFSP, but all studies treat all factories as the same,
rithm (DABC) for the DHNWFSP. First, four neighborhood search
and this situation is called isomorphism. Naderi and Ruiz first
operators based on the characteristics of the problem are used.
studied the DPFSP in 2009 and established six mixed-integer
Second, a speed-up method of inserting and swapping neigh-
linear programming (MILP) models [10]. Victor and Jose pro-
borhood evaluation is proposed to accelerate the neighborhood
posed a bounded-search iterated greedy algorithm for solving the
evaluation process. The employed bee phase and onlooker bee
DPFSP [13]. Wang et al. proposed an effective estimation of the phase are designed according to the above operators. Finally, a
distribution algorithm (EDA) for the DPFSP [14]. A probabilistic VND algorithm based on the four local search methods of four
model was established for describing the solution space and gen- neighborhood structures is embedded into the scout bee phase
erating new individuals through a sampling of the probabilistic to strengthen the local search ability of the DABC.
model. For a DPFSP with the makespan as an objective, Bargaoui The rest of the paper is organized as follows. In Section 2, the
et al. proposed a new chemical reaction optimization (CRO) algo- distributed heterogeneous no-wait flowshop scheduling problem
rithm with four molecular operations to perform a global search is formally defined. In Section 3, the DABC is explained in de-
and local search [15]. Recently, Ruben et al. designed a simple tail. In Section 4, the computation results are given. Finally, a
iterative greedy algorithm for the DPFSP and found the overall conclusion and future works are discussed in Section 5.
upper bound of 497 individual upper bounds [16]. Meng et al.
considered a new DPFSP with customer order constraints and 2. Problem formulation
proposed three meta-heuristics, namely, a variable neighborhood
descent algorithm (ORVND), an artificial bee colony algorithm 2.1. Problem definition
(ORABC), and an iterated greedy algorithm (ORIG), for solving this
problem [17]. Currently, there is little research being conducted The distributed heterogeneous no-wait flowshop scheduling
on the DNWFSP problem. In 2016, Shih and Kuo first proposed problem can be described as follows. There are n jobs in a job
the DNWFSP to minimize the makespan as objective [11]. They set N = {1, 2, . . . , n} that need to be assigned to one of the
proposed an iterated cocktail greedy algorithm (ICG) with two distinct factories in a factory set F = {1, 2, . . . , f }. Each of these f
self-tuning mechanisms and a cocktail destruction mechanism. distinct factories can process all jobs. The number of machines in
One year later, Komaki and Malakooti proposed a general variable each factory is different, and the quantity of machines in a given
neighborhood search (GVNS) for the DNWFSP with the makespan factory is ml , l ∈ {1, 2, . . . , f }. The transport time of assigning a
optimization criterion [18]. In their approach, three shaking pro- job to each factory is rl , l ∈ {1, 2, . . . , f }. Once a job is assigned
cedures and a variable neighborhood descent (VND) based on four to a factory, all operations must be processed only in this factory.
neighborhood structures are embedded in the GVNS. At the same An operation Ol,i,j means that job j is processed on machine i in
time, an iterated greedy algorithm was proposed by Shao and Pi factory l, and the processing time of Ol,i,j is expressed as pl,i,j . pl,i,j
et al. [19] for solving the DNWFSP. Four local search methods, is nonnegative and includes the setup time of Ol,i,j . The machine
2
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Table 1 Table 2
Notation of DHNWFSP MILP. Data of example.
Notation Description F rl N
f = the number of factories 1 2 3 4 5 6
n = the number of jobs 84 52 41 44 79 20
F = {1, 2, . . . , f }, the set of factories 1 178
19 28 84 15 99 72
N = {1, 2, . . . n}, the set of jobs 83 79 8 29 30 49
j = the index of job, j ∈ N 2 129 10 23 14 35 1 38
k = the index of position, k∈ N 16 61 90 35 32 3
l = the index of a factory, l ∈ {1, 2, . . . , f }
ml = the number of a machine in factory l, l ∈ {1, 2, . . . , f }
i = the index of machine i ∈ {1, 2, . . . , ml }
pl,i,j = the processing time of job j on a machine i in factory l
rl = the transport time of the job assigned to factory l, Xl,k,j ∈ {0, 1}, j ∈ {1, 2, . . . , n}, k ∈ {1, 2, . . . , n},
l ∈ {1, 2, . . . , f }
l ∈ {1, 2, . . . , f } (9)
Cl,i,k = the complete time of the job in position k on a machine i
in factory l
Cmax = the makespan
Constraints (3) and (4) mean that the job j is unique in the
given schedule of the assigned factory. Constraint (5) represents
the completion time constraint of the job on the first machine in
the first position in the factory. Constraint (6) limits the comple-
processes the jobs according to the first-come, first-served rule, tion times of two adjacent jobs on the same machine in factory
and the jobs go through each machine in the same order. At any l. Constraint (7) means that the completion time constraints of
time, each machine can process at most one job and each job the same job on two adjacent machines satisfy the no-wait re-
can be processed on at most one machine. Each operation cannot quirement. Constraint (8) represents that the completion time is
be interrupted once it starts. There is no waiting time between greater than or equal to 0. Constraint (9) guarantees that Xl,k,j is
consecutive operations, and this indicates that the start of a job a binary variable.
must be delayed on the first machine when necessary. The aim of
this problem is to find an optimal scheduling for the jobs assigned
to a factory and find a sequence for processing all jobs on all 2.2. The method for calculating the makespan
machines in a certain factory such that its maximum makespan is
minimized. Heterogeneity is first considered in the DPFSP (which
also includes the DNWFSP), so the makespan is chosen as a classic Let π l = {π1l , π2l , . . . , πnl l } be a sequence of jobs in factory l,
objective in this paper. where nl denotes the number of jobs assigned{ to factory l. The
solution to the problem is represented as π = π 1 , π 2 , . . . , π f .
}
Notations including the relevant parameters and indices for
this scheduling model are listed in Table 1. Let dl,πj−1 ,πj be the minimum delay between the start of job πj and
The MILP model of DHNWFSP is defined as follows. job πj−1 on the first machine when job πj is processed directly
The decision variable is: after job πj−1 because of the no-wait constraint. This delay can
{
1, if job j is processed on position k in factory l be calculated as follow:
Xl,k,j =
0, other w ise
[ { k k−1
}]
∑ ∑
dl,πj−1 ,πj = pl,1,πj−1 + max 0, max pl,h,πj−1 − pl,h,πj
j, k ∈ {1, 2, . . . , n} l ∈ {1, 2, . . . , f } (1) 2≤k≤ml
h=2 h=1
The objective function is: l ∈ {1, 2, . . . , f } , j ∈ {2, 3, . . . , n} (10)

Minimise Cmax = min(max(Cl,ml ,k )), k ∈ {1, 2, . . . , n}, l ∈ {1, 2, . . . , f } tpl,j denotes the sum of the processing times for each machine
(2) in factory l, and it is calculated as follows.
ml
The constraints are: ∑
f n
tpl,j = pl,i,j l ∈ {1, 2, . . . , f }, j ∈ {1, 2, . . . , n} (11)
∑ ∑ i=1
Xl,k,j = 1, j ∈ {1, 2, . . . , n} (3)
l=1 k=1 Then, the completion time of factory l can be calculated as
∑∑f n follows.
Xl,k,j = 1, k ∈ {1, 2, . . . , n} (4) n l
∑
l=1 j=1
Cmax (π ) = rl +
l
dl,π l ,πjl + tpl,π l l ∈ {1, 2, . . . , f } (12)
n j−1 nl
∑ j=2
Cl,1,1 = rl + Xl,1,j pl,1,j l ∈ {1, 2, . . . , f } (5)
j=1 So the makespan is
n
Cmax (π ) = max{Cmax (π l )} l ∈ {1, 2, . . . , f } (13)
∑
Cl,i,k+1 ≥ Cl,i,k + Xl,k+1,j pl,i,j , k ∈ {1, 2, . . . , n − 1},
j=1 The value of dl,πj−1 ,πj is only related to πj−1 and πj . dl,πj−1 ,πj
i ∈ {1, 2, . . . , ml }, l ∈ {1, 2, . . . , f } (6) and tpl,j can be calculated in advance, thereby decreasing the time
n complexity of the problem to O(m). Therefore, the computational
complexity of Cmax (π) can be reduced to O(fn).
∑
Cl,i+1,k = Cl,i,k + Xl,k,j pl,i+1,j , k ∈ {1, 2, . . . , n},
j=1
An example with 6 jobs and 2 factories is given in Table 2
to effectively illustrate the MILP involved in the problem. The
i ∈ {1, 2, . . . , ml − 1}, l ∈ {1, 2, . . . , f } (7) sequences of two factories are π 1 = {6, 2, 4} and π 2 = {3, 1, 5}.
Cl,i,k ≥ 0, k ∈ {1, 2, . . . , n}, i ∈ {1, 2, . . . , ml }, l ∈ {1, 2, . . . , f } The completion times of the two factories are 329 and 294, so the
(8) makespan is 329. The Gantt chart is shown as follows in Fig. 1.
3
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

The above canonical artificial bee colony is designed for con-

tinuous optimization problems, so many researchers have pro-
posed many discrete artificial bee colony algorithms for various
shop scheduling problems. Therefore, we propose a novel discrete
variant of the artificial bee colony algorithm for the DHNWFSP in
this section.

3.1. Solution representation

This paper uses the representation method proposed by Naderi

and Ruiz [10]. The solution consists of f lists, and each list
represents a factory by denoting a job sequence, which describes
the processing order of jobs assigned to this factory. An example
is given to illustrate this encoding method. Suppose there are
8 jobs and 2 factories that need to be processed. Jobs 1, 3, 6,
and 7 are assigned to factory 1, and jobs 2, 4, 5, and 8 are
assigned to factory 2. Thus, the solutions for factories 1 and 2
are {6, 1, 7, 3} , {2, 8, 5, 4}.

3.2. Initialization

The NEH algorithm is widely used in the initialization phases

of metaheuristic algorithms for solving flow shop scheduling
problems. Naderi and Ruiz first proposed two versions of the NEH
Fig. 1. The Gantt of the example.
algorithm for the DPFSP according to different assignment rules.
The first is to assign a job to the factory with the lowest current
makespan, not including the insertion process, and this version
3. Proposed discrete artificial bee colony algorithm is named NEH1; the second is to assign the job to the factory
with the lowest current makespan after inserting the job, and
this version is named NEH2. Their experimental results showed
that the NEH2 algorithm is better than other constructive heuris-
Inspired by the foraging behavior of honeybee swarms in
tic algorithms. Due to the characteristic of heterogeneity in the
nature, Karaboga et al. [25] proposed a canonical artificial bee
DHNWFSP, a basic NEH2 algorithm cannot be used to generate
colony algorithm for the optimization of multivariable and mul-
an initial solution. This paper uses a method similar to NEH2 to
timodal continuous functions. Foraging artificial bees are divided
initialize the population. For each individual in the population,
into three categories in the ABC algorithm, namely, employed
the following algorithm (Algorithm 2) is used for initialization.
bees, onlookers, and scouts. Employed bees exploit the nectar
We randomly generate an initial sequence and then use step 2
sources that are known and then send information about the
of NEH2. Through this method, the quality and diversity of the
quality of the food source to the bees waiting in the hive. The
population are guaranteed.
onlookers decide to search for food sources based on the informa-
tion acquired from the employed bees. According to their internal
motivations, external clues, or random chance, scouts search for
new food sources. In the ABC algorithm, each food source denotes
a solution and is exploited by only one employed bee. The amount
of nectar in the associated food resource represents the fitness of
the solution. The number of employed bees or onlooker bees is
equal to the number of food sources. The canonical ABC algorithm
is described as follows.

3.3. Neighborhood structures

A neighborhood structure is described as performing a cer-

tain operation on the incumbent feasible solution to generate
a new feasible solution. Various neighborhood structures have
4
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

′′
been proposed for searching the solution space of an incum- Cmax (π l ) = Cmax (π l ) − dl,π l ,πjl − tpl,π l + tpl,π l if j = nl ; (15)
j−1 j j−1
bent solution. However, all neighborhood operations need to l′′
ensure that the resulting solution is feasible. Each neighborhood Cmax (π ) = Cmax (π ) − dl,π l l
,πjl − dl,π l ,π l + dl,π l ,πjl+1 if 1 < j < nl ;
j−1 j j+1 j−1
structure corresponds to a different solution space, and mul- (16)
tiple neighborhood structures help to find multiple solutions.
In distributed scheduling problems, the crucial factory is the Then, for inserting the removed job into position k, the com-
factory with the largest completion time. Changes in the cru- pletion time can be calculated as follows. The computational
cial factory cause changes in the overall completion time. Based complexity is O(1).
on this fact, four neighborhood structures are adopted. These ′ ′′
Cmax (π l ) = Cmax (π l ) + dl,π l ,π l′′ if k = 1; (17)
neighborhood structures can be classified into two classes. One j k

class involves working within a crucial factory, and it includes l′ l′′

Cmax (π ) = Cmax (π ) + dl,π l′′ ,πjl
− tpl,π l′′ + tpl,π l if k = nl ; (18)
j
Insert_within_Crifac and Swap_within_Crifac. The other involves k−1 k−1
l′ l′′
working between factories, and it includes Insert_between_Crifac Cmax (π ) = Cmax (π ) + dl,π l′′ ,πjl
+ dl,π l ,π l′′ − dl,π l′′ ,πkl
′′ if 1 < k < nl ;
k−1 j k k−1
and Swap_between_Crifac. More details about these neighborhood
(19)
structures are described as follows.
(1) N1(Insert_within_Crifac): Insert the neighborhood structure 3.4.2. Insertion between factories
within a critical factory. In the critical factory, randomly Let v (a, b, j, k) be the operation for insertion between facto-
choose two positions j and k; remove the job in position ries, meaning that the job in position j of factory a is removed
j and then insert the same job in position k. and then inserted in position k of factory b. π a represents the job
(2) N2(Swap_within_Crifac): Swap the neighborhood structure ′
sequence of factory a before removing the job in position j. π a is
within a critical factory. In the critical factory, randomly the job sequence of factory a after removing the job. π denotes
b
choose two positions j and k; swap the jobs in positions the job sequence of factory b before inserting the job in position
j and k. ′
k. π b denotes the job sequence of factory b after inserting the
(3) N3(Swap_between_Crifac): Swap the neighborhood struc- job. Let na and nb be the numbers of jobs assigned to factory a
ture between critical factories. First, select factory b ran- and factory b, respectively.
domly (b cannot be the critical factory). Then, choose a The calculation of the overall completion time can be car-
position j in the critical factory and a position k in factory ried out according to the above two formulas in Section 3.4.1.
b randomly. Last, swap the jobs in positions j and k. ′
Cmax (π a ) is the completion time after removing the job in po-
(4) N4(Insert_between_Crifac): Insert the neighborhood struc- sition j of factory a, and it can be calculated as follows. The
ture between critical factories. Randomly choose a position computational complexity is O(1).
j in a critical factory and remove this job. Then, insert this
′
job into an arbitrary position k of an arbitrary factory b Cmax (π a ) = Cmax (π a ) − da,π a ,π a if j = 1; (20)
j j+1
(which cannot be the critical factory). a′
Cmax (π ) = Cmax (π ) − da,π a
a
,πja − tpa,πja + tpa,πja−1 if j = n ; a
(21)
j−1
An example that better describing these four neighborhood a′
Cmax (π ) = Cmax (π ) − da,π a
a
,πja − da,πja ,πja+1 + da,πja−1 ,πja+1 if 1 < j < na ;
structures better is given as follows in Fig. 2. j−1

(22)
3.4. Speed-up method of inserting and swapping neighborhood eval- ′
Cmax (π b ) is the completion time after inserting a job in posi-
uation tion k of factory b. It can be calculated as follows. The computa-
tional complexity is O(1).
The movement of a neighborhood is usually the most time- ′
consuming operation in an algorithm. In the flowshop scheduling Cmax (π b ) = Cmax (π b ) + db,π a ,π b if k = 1; (23)
j k
problem, inserting and swapping are the most common oper- b′
Cmax (π ) = Cmax (π ) + db,π b ,π a − tpb,π b + tpb,π a
b
if k = n + 1; b
(24)
ations. In the DHNWFSP, the insertion neighborhood operation k j k j

b′
is divided into insertion-within-factory and insertion-between- Cmax (π ) = Cmax (π ) + db,π b
b
,πja + db,π a ,π b − db,π b ,πkb if 1 < k < n + 1; b
k−1 j k k−1
factory operations. The swapping of neighborhood operations, can
(25)
also be separated into two types: swapping-within-factory and
swapping-between-factory. To speed up the process of evaluating
neighborhood operators, this paper proposes a speed-up method 3.4.3. Swapping within factories
for inserting and swapping neighborhood evaluations accord- Let s (j, k) denote the operation of swapping the jobs in posi-
ing to the speed-up method for the NWFSP proposed by Qian tion j and position k of factory l, j ̸ = k. π l is the job sequence be-
′
et al. [40] and Pan et al. [41]. The details of inserting and swapping fore swapping, and π l is the sequence after swapping. Thus, the
neighborhoods and their speed up methods are described as completion time can be calculated as follows. The computational
follows. complexity is O(1).
(1) Swapping the jobs in position 1 and nl : j = 1, k = nl
′
3.4.1. Insertion within a factory Cmax (π l ) = Cmax (π l ) − dl,π l ,π l − dl,π l ,πkl − tpl,π l
Let v (j, k) be the operation for insertion within a factory. j j+1 k−1 k

Specifically, remove the job at position j in factory l and reinsert + dl,π l ,π l + dl,π l ,π l + tpl,π l (26)
k j+1 k−1 j j
it at position k. Let π l be a sequence of jobs in factory l, π l′ be a
′′ if j = 1, k = n ; l
sequence of jobs in factory l after insertion and π l be a sequence
of jobs in factory l after removing the job at position j. (2) Swapping the jobs in position 1 and 2: j = 1, k = 2
After removing the job at position j, the completion time can ′
be calculated as follows. The computational complexity is O(1). Cmax (π l ) = Cmax (π l ) − dl,π l ,π l − dl,π l ,π l + dl,π l ,π l + dl,π l ,π l
j k k k+1 k j j k+1

l′′
Cmax (π ) = Cmax (π ) − dl,π l ,π l
l
if j = 1; (14) if j = 1, k = 2; (27)
j j+1

5
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. 2. The example of four neighborhood structure.

′
(3) Swapping the jobs in position 1 and k: j = 1, 2 < k < nl Cmax (π l ) = Cmax (π l ) − dl,π l ,πjl − dl,π l ,π l − dl,π l ,πkl
j−1 j j+1 k−1

′ − dl,π l ,π l + dl,π l + dl,π l ,π l + dl,π l

Cmax (π l ) = Cmax (π l ) − dl,π l ,π l − dl,π l ,πkl − dl,π l ,π l k k+1 j−1
,πkl k j+1 k−1
,πjl
j j+1 k−1 k k+1

(28) + dl,π l ,π l if 1 < j < n , 1 < k < n , k − j > 1;

l l
+ dl,π l ,π l + dl,π l ,πjl + dl,π l ,π l j k+1
k j+1 k−1 j k+1

if j = 1, 2 < k < nl ; (32)

(4) Swapping the jobs in position nl −1 and nl : j = nl −1, k = nl

3.4.4. Swapping between factories
′
Let s(a, b, j, k) be the operation of swapping the job in position
Cmax (π l ) = Cmax (π l ) − dl,π l ,πjl − dl,π l ,π l − tpl,π l j of factory a with the job in position k of factory b. π a is the
j−1 j k k ′
job sequence of factory a before swapping, and π a is the job
+ dl,π l ,π l + dl,π l ,π l + tpl,π l (29)
j−1 k k j j sequence of factories a after swapping.
if j = nl − 1, k = nl ; The completion time can be calculated as follows. The compu-
tational complexity is O(1).
(5) Swapping the jobs in position j and nl : 1 < j < nl −1, k = nl (1) Swapping the job in position 1 of factory a with the job in
position k of factory b: j = 1
′
′
Cmax (π l ) = Cmax (π l ) − dl,π l − dl,π l ,π l Cmax (π a ) = Cmax (π a ) − da,π a ,π a + da,π b ,π a if j = 1; (33)
,π l
j−1 j j j+1
j j+1 k j+1

− dl,π l ,πkl − tpl,π l + dl,π l ,πkl + dl,π l ,π l + dl,π l ,πjl + tpl,π l (2) Swapping the job in position na of factory a with the job
k−1 k j−1 k j +1 k−1 j
in position k of factory b: j = na
if 1 < j < nl − 1, k = nl ;
′
(30) Cmax (π a ) = Cmax (π a ) − da,πja−1 ,πja − tpa,πja + da,π a ,πkb + tpa,πkb if j = na ;
j−1

(6) Swapping the jobs in position k − 1 and k: j = k − 1, 2 < (34)

k < nl
(3) Swapping the job in position j of factory a with the job in
l′
Cmax (π ) = Cmax (π ) − dl,π l l
− dl,π l ,π l − dl,π l ,π l position k of factory b: 1 < j < na
j −1
,πjl j k k k+1
′
+ dl,π l ,π l + dl,π l ,π l + dl,π l ,π l (31) Cmax (π a ) = Cmax (π a ) − da,π a ,πja − da,πja ,πja+1
j−1 k k j j k+1 j−1

if j = k − 1, 2 ≤ k ≤ n ; l
+ da,π a ,πkb + da,π b ,π a if 1 < j < na ; (35)
j −1 k j+1

(7) Swapping the jobs in position j and k: 1 < j < nl , 1 < k < Similarly, the completion time of factory b can also be calcu-
nl , k − j > 1 lated according to the above formulas.
6
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

3.5. Employed bee phase 3.6. Onlooker bee phase

In the canonical ABC algorithm, onlooker bees use roulette

In the employed bee phase of the canonical ABC algorithm,
wheel selection to select individuals for the neighborhood search.
employed bees generate new feasible solutions in the neighbor-
In the roulette wheel selection algorithm, the probability of an
hoods of their current solutions. Therefore, the design of the
individual being selected depends on its fitness. Generally, it is
neighborhood search is critical for the ABC algorithm. In this
necessary to calculate the cumulative fitness of all individuals in
paper, we propose a neighborhood search strategy for the em-
the population to calculate the selection probabilities. Therefore,
ployed bee phase and the onlooker bee phase to generate new
the roulette wheel selection method takes a long time, so it is
neighborhood solutions. Each food source records the current
inefficient. However, tournament selection is widely used in other
neighborhood structure being used. If the neighborhood solution
algorithms due to its simplicity and ability to escape from local
generated at this time is better than the old solution, the food
optima. Therefore, tournament selection is used in the onlooker
source continues to use the current neighborhood, otherwise,
bee phase of our DABC algorithm to improve efficiency and avoid
the food source switches to the new neighborhood structure.
falling into local optima. Specifically, TN food sources (individu-
Four neighborhood structures are recycled in order. First, all food
als) in the current population are chosen, and the fitness values
sources in the population use the first neighbor structure. The
of those food sources are compared. Onlooker bees choose the
neighborhood search strategy is described as follows.
best food source and then use the neighborhood search strategy
in Section 3.4.
In addition, unlike in the canonical ABC algorithm, in our
algorithm, the greedy selection mechanism is adopted (if and only
if the neighborhood solution is better than the current solution,
the current solution is replaced by the neighborhood solution). In
our proposed DABC, a new population update mechanism is pro-
posed. The Popsize newly generated individuals and the current
population are combined, and then the Popsize top individuals
who are distinct from each other are selected. Some studies have
shown that the main determinants of the population evolution
rate are the worst individuals rather than the best individuals.
This population update method can effectively guarantee the
overall quality of the population during the evolution process.
Therefore, the algorithm can converge to the optimal solution
quickly. Additionally, it is guaranteed that there are no identical
individuals in the population, thereby increasing the diversity
of the population and avoiding premature convergence of the
algorithm.
The algorithm for the onlooker bee phase can be described as
follows.

In the employed bee phase, each employed bee uses the above
neighborhood search strategy to generate a solution within the
neighborhood of its corresponding food source. For each food
source exploited by the employed bee, the neighborhood search
operation is performed SN times. The larger SN is, the stronger
the ability of the bees to perform the local search. Therefore, the
algorithm for the employed bee phase is as follows.

3.7. Scout bee phase

In the canonical ABC algorithm, a scout bee phase produces a

food source randomly, but this decreases the convergence speed
of the algorithm. The employed bee phase and onlooker bee phase
of the DABC possess a strong diversification ability. However,
the DABC lacks intensification ability. To improve the ability of
the algorithm to perform local searches, we propose a kind of
7
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

variable neighborhood descent (VND) algorithm to systemati- factory: remove each job, try to insert it into all positions of the
cally change the neighborhood and local searches in the scout remaining factories, and then insert it in the optimal position. If
bee phase to those of the best individual in the current pop- the neighborhood solution is better than the input solution, the
ulation. If they are improved, the best food source in the cur- input solution is replaced. The above process is repeated until
rent population is replaced. Four local search algorithms based there is no improvement.
on the neighborhood structures in Section 3.3 are adopted in
VND. Some of these four local search methods are also designed
based on LS_insert_citical_factory1 and LS_insert_citical_factory2
from Ref. [19].
(1) LS1 local search for an Insert_within_Crifac neighbor-
hood structure
LS1 is the same as LS_insert_citical_factory1 in Ref. [19]. The
operations are executed as follows for all jobs in a critical factory:
remove each job and insert it into the best position within a
critical factory. If the neighborhood solution is better than the
input solution, the input solution is replaced. The above process
is repeated until there is no improvement.
The pseudocode of LS1 is shown as follows.

(4) LS4: local search for a Swap_between_Crifac neighbor-

hood structure
The operations are executed as follows for all jobs in a critical
factory: swap each job in a critical factory with all jobs in the
other factories, and keep the best neighborhood solution. If the
neighborhood solution is better than the input solution, the input
(2) LS2 local search for a Swap_within_Crifac neighborhood solution is replaced. The above process is repeated until there is
structure no improvement.
The operations are executed as follows for all jobs in a crit- (5) VND algorithm
ical factory: swap each job and all jobs behind it in the job Variable neighborhood descent is a simple but effective local
sequence and recode the best swapping pair. If the neighborhood search method based on the systematic changes in neighbor-
solution is better than the input solution, the input solution is hoods. In the VND algorithm, the different neighborhoods are
replaced. The above process is repeated until there is no improve- systematically searched in order from the smallest to largest. VND
ment. starts from the first neighborhood and runs iteratively until a lo-
(3) LS3: local search for an Insert_between_Crifac neighbor- cal minimum is reached. If there is no further improvement in the
hood structure kth neighborhood, the search process switches to neighborhood
LS3 is the same as LS_insert_citical_factory2 in Ref. [19]. k+1. When an improved solution is found, the search process
The operations are executed as follows for all jobs in a critical restarts from the first neighborhood. When all neighborhoods

8
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

are searched and there is no improvement, the search process 4. Experimental result and analysis
stops and returns the final solution. Based on the above four
local search methods, we propose a VND algorithm as the scout In this section, a numerical experiment is executed to prove
bee phase of the DABC for improving its local search ability. The the effectiveness of the proposed DABC algorithm for solving
pseudocode is as follows. DHNWFSP of different scales. The proposed algorithm is cali-
brated and compared with the best algorithms that were pro-
3.8. Discrete artificial bee colony algorithm posed previously for the DPFSP or DNWFSP. These algorithms
include the ICG [11] proposed by Shi-Wei Lin et al. in 2016, the
All components of the DABC have been introduced in the GVNS [18] proposed by Komaki et al. in 2017, and the CRO [15]
above section. In this section, the pseudocode of the DABC is given proposed by Bargaoui et al. in 2017. All algorithms are coded
in Algorithm 11. The DABC consists of four parts, namely the in C++, and the experiments are implemented on a PC with an
initialization phase, the employed bee phase, the onlooker bee Intel Core i5-8300H, 8 GB RAM, and a Windows 10 operating
phase, and the scout bee phase. system. In addition, CPLEX 12.8 with default settings is used
In the initialization phase, the parameters of the DABC are for the comparative experiment. Moreover, the details of the
set first, and then the NEH2 and INEH2 algorithms are used experimental design and experimental results are given in the
to initialize the population. In the employed bee phase, all in- next few sections.
dividuals adopt the neighborhood search strategy to improve
themselves. In the onlooker bee phase, the best individual is
selected through the tournament selection algorithm to perform 4.1. Design of the experiments
a neighborhood search strategy. Then, the current population and
the newly generated population are merged and updated. In the To evaluate the performance of the proposed DABC for prob-
scout bee phase, the VND algorithm is used to perform a local lems of different scales, a series of experiments are designed.
search for the best individual. The above process is repeated until Generally, DHNWFSPs are divided into small-scale problems and
the termination criteria are met. large-scale problems according to whether the number of jobs is
less than 20.

9
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Table 3
The parameters of compared algorithms.
Algorithm Parameter Parameter value
GVNS No parameter None
InitialKE 8
KELossRate 0.2
α 200
CRO
β 4
PopSize 40
MoleColl 0.5
buffer 0
T0 2.5
Iiter 2500
ICG λ 0.9
αmin 2
ηmin 1
max
Inon −improv ing 1.5 × Iiter

Since there is no benchmark for the DHNWFSP, we gener-

ate the experimental instances. For a small scale, the number
of factories f is chosen from {2, 3}. the number of jobs n is
chosen from {6, 10, 14}. The number of machines ml is generated
randomly and, obeys a uniform distribution U[0.8m, 1.2m], where
m is chosen from {3, 5}. Even if each no-wait flowshop is the
same, the processing capacities are different. However, the gap
in processing capacity between each factory is not too large, so
the number of machines is set at ±20%. The transport time is
related to the number of factories, and it is a random number
that obeys a uniform distribution U[50f, 100f ]. The processing
time pl,i,j of the operation Ol,i,j is generated randomly from U [1,
100]. Similarly, for a large-scale problem, the number of factories
is F = {2, 3, 4, 5, 6}, and the combination of jobs and machines
is N × M = {{20, 50, 100, 200} × {5, 10, 20} , {500} × {10, 20}}.
The transport time obeys a uniform distribution U[100f, 300f ]
and is generated randomly. The processing time pl,i,j is generated
randomly from U[1, 100]. Five different instances are gener-
ated for each small-scale problem combination. However, ten
instances are generated for each large-scale problem. Therefore,
there are 60 instances of small-scale problems and 700 instances
of large-scale problems.
In all experiments, all algorithms use the same stopping crite-
ria, the same coding and decoding methods, the same speed-up
method proposed in this paper, the same initialization method
(NEH2 proposed in Section 3.2) and the same parameters, which
are the same as those in the original literature. The parameters
of the compared algorithms are listed in Table 3.
To measure the computation results obtained by the compared
algorithms and CPLEX, the relative percentage deviation (RPD),
average (ARPD), minimum (Min), maximum (Max), and standard
deviation (SD) of each algorithm are calculated as follows.

• RPD denoted the measures of the relative quality of solu-

tions.
Ci − Copt
RPD = × 100% (36)
Copt
which Ci is a solution obtained by a specific algorithm in the
ith instance, Copt is the best solution to obtain all algorithms
or CPLEX.
• ARPD is the average of RPD
R
1∑
ARPD = RPD (37)
R
i=1

which R is the replications of the algorithm.

• MinRPD is the minimum of RPD;
• MaxRPD is the maximum of RPD;
10
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. 3. Mean effect plot for Popsize, SN, and TN.

• SD is the degree of solution closeness to the mean solution Table 4

and robustness of the algorithm. The factor level of DABC algorithm.
 Parameter Level
 R
1 ∑ 1 2 3 4
SD = √ (RPD − ARPD)2 (38) Popsize 30 50 80 100
R
i=1 SN 3 5 8 10
TN 2 3 4 5
4.2. Parameter calibration
Table 5
This section carries out a full factorial experiment and a The result of the parameter calibration experiment.
Taguchi experiment to calibrate the proposed DABC for the pur- Num Popsize SN TN AveMakespan (RV)
pose of improving its effectiveness. The controlled factors of the 1 1 1 1 3269
DABC are the size of the population Popsize, the number of neigh- 2 1 2 2 3251
borhood search iterations SN, and the number of tournament 3 1 3 3 3253
selection iterations TN. Each parameter is set to 4 levels, so we 4 1 4 4 3251
5 2 1 2 3269
execute a 3-factor 4-level design of experiments (DOE) approach.
6 2 2 1 3276
The factor levels of the parameters for the DABC are shown in Ta- 7 2 3 4 3248
ble 4. To save time during parameter calibration, this paper uses a 8 2 4 3 3273
medium-scale instance, i.e., F = 4, N = 100, and M = 10. For each 9 3 1 3 3296
parameter combination, the DABC is run 20 times and the average 10 3 2 4 3301
11 3 3 1 3292
makespan AveMakespan is recode as a response value (RV). The 12 3 4 2 3300
termination criterion is f × n × maxm × 10 ms. The notation 13 4 1 4 3308
‘‘maxm’’ denotes the maximum value for the number of machines. 14 4 2 3 3307
The RV results are shown in Table 5. The average RV (ARV) and 15 4 3 2 3299
16 4 4 1 3312
the significance rank of each parameter are listed in Table 6, and
Fig. 3 is a horizontal trend graph of the parameters. From Table 6,
it can be seen that the degree of influence of each parameter on Table 6
the performance of the algorithm is Popsize > SN > TN. The ARVs and the rank of each parameter.
lower the AveMakespan is, the better the combination is. When Level Popsize SN TN
Popsize increases, the effect of the algorithm worsens. This is 1 3256 3286 3287
because a larger population leads to more diversity but also to 2 3267 3284 3280
3 3297 3273 3282
more invalid searches. Therefore, the effect of the algorithm has
4 3307 3284 3277
not been improved. For the given number of neighborhood search Rank 1 2 3
iterations SN and number of tournament selection iterations TN,
there is no obvious linear dependence. When Popsize level 1, SN
level 3, and TN level 4 are chosen, the algorithm works best.
Therefore, the parameters are set as follows: Popsize = 30, SN = in a large-scale problem are chosen. DABC(N−ALL) is the DABC
8 and TN = 5. that uses four neighborhood structures, and its corresponding
local search method is VND. DABC(N1) represents the DABC that
4.3. Effectiveness of the neighborhood structure only uses the first neighborhood structure (Insert_within_Crifac)
and its corresponding local search method. Similarly, DABC(N2) ,
To prove the effectiveness of the neighborhood structure DABC(N3) , and DABC(N4) represent the DABC algorithms that only
adopted in Section 3.3, a numerical experiment is carried out. use the N2, N3, and N4 neighborhood structures, respectively.
Seventy instances are selected from the set of large-scale prob- All algorithms have the same termination criterion, which is a
lems. Specifically, the first instances of various combinations maximum running time of Tmax = f × n × maxm × 8 ms. These

11
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

algorithms are run 5 times and the makespans are recoded. The Table 7
best result among all algorithms is represented as Copt . The results The result of the effectiveness of neighborhood structure.
are listed in Table 7. F N M DABC(N−ALL) DABC(N1) DABC(N2) DABC(N3) DABC(N4)
Form Table 7, DABC(N−ALL) has a smaller ARPD value than other ARPD ARPD ARPD ARPD ARPD
algorithms on all combinations. It shows that using four neigh- 5 0.000 0.029 0.029 0.006 0.014
bor structures simultaneously is better than using one neighbor 20 10 0.000 0.025 0.024 0.005 0.012
20 0.002 0.013 0.018 0.009 0.008
structure. This is because the more neighborhood structures
5 0.001 0.055 0.054 0.027 0.059
used, the larger the solution space that can be searched. The 50 10 0.001 0.041 0.056 0.021 0.062
possibility of obtaining the optimal solution is superior to other 20 0.001 0.049 0.044 0.016 0.055
DABC algorithms that use only one neighborhood structure. So 2
5 0.002 0.066 0.075 0.038 0.113
the DABC(N−ALL) is greater than DABC(N1) , DABC(N2) , DABC(N3) , 100 10 0.003 0.038 0.047 0.030 0.074
20 0.003 0.037 0.043 0.027 0.066
DABC(N4) .
5 0.002 0.067 0.074 0.046 0.130
200 10 0.004 0.042 0.060 0.046 0.094
4.4. Small-scale problem results and analysis 20 0.001 0.035 0.046 0.038 0.075
10 0.002 0.045 0.050 0.051 0.096
500
20 0.003 0.028 0.042 0.050 0.065
After calibrating the proposed DABC, we compare it with some
state-of-the-art algorithms with regard to solving the DFSP and 5 0.000 0.028 0.030 0.007 0.003
20 10 0.000 0.026 0.030 0.005 0.010
DNFSP. These algorithms, including the GVNS [18], CRO [15], 20 0.000 0.051 0.050 0.016 0.007
and ICG [11] algorithms, are reimplemented according to their 5 0.003 0.068 0.079 0.021 0.054
original studies. At the same time, we use CPLEX to solve the 50 10 0.004 0.067 0.070 0.020 0.054
MILP for small-scale problem instances. All algorithms have the 20 0.002 0.050 0.047 0.015 0.045
5 0.002 0.089 0.095 0.037 0.100
same termination criterion, which is a maximum running time 3
100 10 0.003 0.057 0.065 0.020 0.082
Tmax = f × n × maxm × 6 ms. These algorithms run 5 times, 20 0.003 0.057 0.056 0.024 0.073
and the makespans are recoded. ‘‘maxm’’ is the maximum number 5 0.002 0.098 0.112 0.043 0.144
of machines in all factories. CPLEX returns an optimal solution if 200 10 0.004 0.065 0.074 0.037 0.102
the running time is less than 30 min (1 800 000 ms). Otherwise, 20 0.001 0.046 0.051 0.033 0.077
10 0.002 0.065 0.079 0.046 0.117
CPLEX returns an approximate optimal solution. In Section 4.1, 500
20 0.003 0.050 0.061 0.045 0.084
RPD is used as an evaluation criterion is used to the effective-
5 0.007 0.034 0.044 0.001 0.008
ness of all algorithms, including the DABC, GVNS, CRO, and ICG 20 10 0.000 0.042 0.045 0.013 0.006
algorithms. For small-scale problems, the best solution among all 20 0.000 0.033 0.051 0.006 0.011
algorithms and CPLEX is represented as Copt . 5 0.004 0.059 0.065 0.015 0.036
The results for small-scale problems, including the ARPD, Min- 50 10 0.003 0.052 0.062 0.017 0.040
20 0.003 0.051 0.060 0.014 0.038
RPD, MaxRPD, and SD values, are listed in Table 8. From Table 8,
5 0.003 0.070 0.078 0.014 0.069
it can be obtained that the CRO and ICG algorithms, whose mean 4
100 10 0.002 0.090 0.093 0.031 0.089
ARPD values are both 0.251%, are slightly better than the DABC, 20 0.002 0.054 0.059 0.024 0.074
whose ARPD is 0.283%. This is because CRO and ICG are more 5 0.002 0.094 0.101 0.034 0.116
stable than the DABC. This slight gap in algorithmic efficiency is 200 10 0.003 0.081 0.089 0.034 0.107
20 0.002 0.063 0.074 0.028 0.091
tolerable. For the MinRPD column,DABC has 6 out of 60 instances 10 0.004 0.086 0.097 0.046 0.131
in which the optimal solution of this small-scale problem is not 500
20 0.001 0.056 0.067 0.039 0.090
obtained, but the CRO and ICG algorithms both have 5 out of 5 0.009 0.029 0.032 0.005 0.002
60 instances in which they do not reach the optimal solution. 20 10 0.026 0.056 0.059 0.031 0.006
There may be two reasons for this phenomenon. The first is that 20 0.000 0.056 0.058 0.007 0.007
the DABC is a population-based algorithm, so the DABC has too 5 0.002 0.078 0.075 0.025 0.030
50 10 0.003 0.059 0.056 0.015 0.029
much diversification to be able to converge quickly to the optimal
20 0.002 0.054 0.059 0.012 0.029
solution. The second reason is that the DABC has 4 different 5 0.004 0.085 0.086 0.025 0.069
5
neighborhood structures that lead to a large solution space. GVNS 100 10 0.002 0.074 0.086 0.021 0.075
obtains the largest ARPD value, which makes it worse than all 20 0.001 0.057 0.062 0.017 0.061
other algorithms. In terms of the stability of the algorithms, 5 0.003 0.098 0.104 0.037 0.108
200 10 0.001 0.078 0.089 0.028 0.102
CRO and ICG are the best. The DABC is slightly worse than the 20 0.003 0.068 0.069 0.031 0.083
others. However, the performance of the DABC in small-scale 10 0.002 0.086 0.097 0.043 0.127
500
problems may be only slightly worse than those of the CRO and 20 0.001 0.059 0.074 0.035 0.091
ICG algorithms. To further evaluate the performances of those 5 0.000 0.080 0.088 0.075 0.000
algorithms, a two-sample t-test is executed, and the result is 20 10 0.006 0.230 0.243 0.222 0.010
given in Table 9. The p-values of DABC-GVNS, DABC-CRO, and 20 0.003 0.265 0.263 0.249 0.028
5 0.002 0.046 0.043 0.014 0.018
DABC-ICG are 0.116, 0.849, and 0.849, respectively, and they are 50 10 0.008 0.042 0.042 0.000 0.005
all greater than 0.05. Therefore, the DABC has no difference in 20 0.005 0.064 0.066 0.014 0.028
performance when compared with the other algorithms. 5 0.007 0.056 0.061 0.015 0.048
6
To comprehensively study the differences and performance 100 10 0.004 0.065 0.066 0.014 0.059
20 0.001 0.056 0.051 0.014 0.054
trends among the compared algorithms, the factors of the ex-
5 0.001 0.107 0.118 0.039 0.106
periments, i.e., the numbers of factories, jobs, and machines, are 200 10 0.003 0.086 0.093 0.029 0.100
considered separately. Figs. 4 to 6 are the mean plots with 95% 20 0.002 0.057 0.071 0.021 0.073
confidence intervals for the interactions between the algorithms 500
10 0.003 0.095 0.102 0.041 0.127
and F, N, and M. It is clear that the DABC, CRO, and ICG algorithms 20 0.002 0.073 0.079 0.037 0.097
are statically equivalent with regard to f, n, and m. GVNS is Mean 0.003 0.064 0.071 0.032 0.062
worse than the other three algorithms. Through a t-test and
mean plots with 95% confidence intervals for the interactions
12
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Table 8
The result of small-scale problem.
F × N × M Num CPLEX DABC GVNS CRO ICG
Makespan CPU ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD
1 377 660 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 329 420 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 × 6 × 3 3 396 330 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 338 250 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 368 340 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 504 450 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 558 540 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 × 6 × 5 3 502 360 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 540 340 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 468 440 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 471 2900 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 388 5260 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 × 10 × 3 3 369 4750 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 453 5040 0.000 0.000 0.000 0.000 1.325 1.325 1.325 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 431 2470 1.160 1.160 1.160 0.000 1.160 1.160 1.160 0.000 1.160 1.160 1.160 0.000 1.160 1.160 1.160 0.000
1 640 8460 0.156 0.156 0.156 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 675 7060 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 × 10 × 5 3 624 8140 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 633 10 440 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 607 5220 0.000 0.000 0.000 0.000 1.647 1.647 1.647 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 565 221 560 0.212 0.000 0.354 0.173 0.354 0.354 0.354 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 489 428 100 1.922 1.840 2.045 0.100 1.840 1.840 1.840 0.000 1.840 1.840 1.840 0.000 1.840 1.840 1.840 0.000
2 × 14 × 3 3 567 301 160 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 519 330 900 0.039 0.000 0.193 0.077 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 564 338 360 0.000 0.000 0.000 0.000 0.177 0.177 0.177 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 771 1 800 000 0.130 0.130 0.130 0.000 0.130 0.130 0.130 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 802 1 800 000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 × 14 × 5 3 771 1 518 960 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 799 2 343 240 0.000 0.000 0.000 0.000 0.125 0.125 0.125 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 689 1 430 880 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 308 280 4.545 4.545 4.545 0.000 4.545 4.545 4.545 0.000 4.545 4.545 4.545 0.000 4.545 4.545 4.545 0.000
2 362 330 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 6 × 3 3 446 30 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 401 430 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 376 350 0.000 0.000 0.000 0.000 4.787 4.787 4.787 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 481 480 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 506 790 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 6 × 5 3 519 750 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 479 550 3.758 3.758 3.758 0.000 3.758 3.758 3.758 0.000 3.758 3.758 3.758 0.000 3.758 3.758 3.758 0.000
5 432 360 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 462 26 140 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 462 20 410 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 10 × 3 3 399 1110 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 464 10 240 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 444 1730 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 539 11 300 0.000 0.000 0.000 0.000 1.113 1.113 1.113 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 557 16 190 0.000 0.000 0.000 0.000 3.052 3.052 3.052 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 10 × 5 3 504 13 390 0.000 0.000 0.000 0.000 2.579 2.579 2.579 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 615 22 780 0.000 0.000 0.000 0.000 2.439 2.439 2.439 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 547 32 670 0.329 0.000 0.548 0.269 0.731 0.731 0.731 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 405 438 380 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 466 936 430 0.172 0.000 0.858 0.343 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 14 × 3 3 479 218 610 4.134 3.758 5.637 0.752 3.758 3.758 3.758 0.000 3.758 3.758 3.758 0.000 3.758 3.758 3.758 0.000
4 509 1 545 490 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 415 136 810 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
1 672 1 800 000 0.450 0.000 0.750 0.367 2.549 2.549 2.549 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
2 599 1 608 890 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
3 × 14 × 5 3 653 1 800 000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
4 671 1 800 000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
5 648 1 800 000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000 0.000
Mean 0.283 0.256 0.336 0.035 0.601 0.601 0.601 0.000 0.251 0.251 0.251 0.000 0.251 0.251 0.251 0.000

Table 9 stopping, and this is repeated 5 times. The completion times are
t-test for DABC with 95% confidence intervals with GVNS, CRO, and ICG in recorded, and the best result among all algorithms is represented
small-scale problem.
as Copt .
Num Algorithm Mean ARPD t-value p-value IsDifferent
The results of the experiment for the large-scale problem are
1 DABC-GVNS 0.283–0.600 −1.59 0.116 No
shown in Table 10. Information on the ARPD, MinRPD, MaxRPD,
2 DABC-CRO 0.283–0.251 0.19 0.849 No
3 DABC-ICG 0.283–0.251 0.19 0.849 No
and SD values obtained is given to show the effect of each
algorithms. The results are grouped by the combination of the
number of factories, the number of jobs, and the median number
of machines. From Table 10, the ARPD of the DABC, with a value
of 0.270%, is the lowest among all algorithms. The ARPD values of
between the algorithms and F, N, and M, we can obtain the same
the other three algorithms increase successively, and these values
conclusion: DABC, CRO, and ICG achieve the same performances
are 3.735%, 5.384%, and 5.601%. Therefore, a preliminary conclu-
on small-scale DHNWFSPs, but GVNS is worse than the other
sion can be drawn: the DABC is the best algorithm among the
three.
four tested algorithms. In the MinRPD column, almost all the best
solutions are obtained by the DABC. Specifically, the DABC obtains
4.5. Large-scale problem results and analysis
62 out of 70 best solutions. However, other algorithms rarely
obtain optimal solutions. Despite this, GVNS is the most stable
To evaluate the performances of the algorithms in large-scale
algorithm among the algorithms. The SD value of GVNS is 0.001%,
problems, all algorithms, including the DABC, GVNS, CRO, and
but those of the DABC, CRO and ICG algorithms are 0.200%, 0.182%
ICG algorithms, are tested under the same situation as that in
and 0.288%, respectively. To further evaluate the performances of
Section 4.3. All algorithms run for Tmax = f ×n×maxm×8 ms until
13
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. 4. Mean plot with 95% confidence intervals for the interaction between the algorithms and F in small-scale problem.

Fig. 5. Mean plot with 95% confidence intervals for the interaction between the algorithms and N in small-scale problem.

Fig. 6. Mean plot with 95% confidence intervals for the interaction between the algorithms and M in small-scale problem.

14
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Table 10
The result of large-scale problem.
F N M DABC GVNS CRO ICG
ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD ARPD MinRPD MaxRPD SD
5 0.179 0.000 0.376 0.149 0.618 0.618 0.618 0.000 0.040 0.000 0.117 0.047 0.101 0.000 0.267 0.113
20 10 0.044 0.000 0.115 0.047 0.581 0.581 0.581 0.000 0.052 0.000 0.117 0.054 0.040 0.000 0.162 0.066
20 0.042 0.000 0.078 0.033 0.514 0.514 0.514 0.000 0.000 0.000 0.000 0.000 0.004 0.000 0.019 0.008
5 0.200 0.000 0.463 0.163 2.276 2.276 2.276 0.000 4.637 4.309 4.954 0.254 4.301 3.706 4.744 0.380
50 10 0.149 0.000 0.283 0.101 2.139 2.139 2.139 0.000 3.543 3.147 3.911 0.281 3.098 2.757 3.424 0.238
20 0.156 0.000 0.328 0.123 2.531 2.531 2.531 0.000 2.808 2.380 3.102 0.263 2.622 2.290 2.923 0.236
5 0.226 0.000 0.464 0.175 4.670 4.670 4.670 0.000 8.265 7.765 8.629 0.318 7.826 7.201 8.374 0.432
2
100 10 0.259 0.000 0.502 0.179 4.101 4.101 4.101 0.000 6.133 5.706 6.485 0.288 5.398 4.940 5.825 0.326
20 0.202 0.000 0.385 0.135 4.278 4.278 4.278 0.000 5.093 4.775 5.345 0.210 4.437 4.112 4.759 0.233
5 0.271 0.000 0.569 0.203 6.118 6.118 6.118 0.000 11.371 11.023 11.685 0.243 11.054 10.741 11.527 0.286
200 10 0.240 0.000 0.424 0.157 6.270 6.270 6.270 0.000 7.732 7.445 7.996 0.198 7.647 7.302 8.086 0.278
20 0.231 0.000 0.439 0.162 5.165 5.165 5.165 0.000 5.826 5.392 6.064 0.245 5.522 5.173 6.003 0.305
10 0.301 0.000 0.564 0.208 7.674 7.674 7.674 0.000 8.364 8.080 8.582 0.186 9.360 9.048 9.763 0.252
500
20 0.264 0.000 0.507 0.178 5.497 5.497 5.497 0.000 5.784 5.557 5.960 0.143 6.205 5.839 6.705 0.304
5 0.100 0.000 0.326 0.136 0.759 0.759 0.759 0.000 0.072 0.039 0.117 0.037 0.038 0.016 0.057 0.019
20 10 0.000 0.000 0.000 0.000 0.935 0.935 0.935 0.000 0.009 0.000 0.043 0.017 0.006 0.000 0.032 0.013
20 0.023 0.000 0.048 0.022 0.688 0.688 0.688 0.000 0.000 0.000 0.000 0.000 0.017 0.000 0.083 0.033
5 0.350 0.000 0.862 0.311 2.071 2.071 2.071 0.000 4.835 4.486 5.235 0.276 4.507 3.910 4.975 0.383
50 10 0.262 0.000 0.529 0.192 2.024 2.024 2.024 0.000 3.657 3.270 3.989 0.255 3.379 2.986 3.764 0.287
20 0.163 0.000 0.342 0.126 2.282 2.282 2.282 0.000 3.310 2.984 3.588 0.220 2.956 2.585 3.278 0.260
5 0.226 0.000 0.463 0.157 3.689 3.689 3.689 0.000 9.049 8.621 9.411 0.284 9.166 8.483 9.861 0.503
3
100 10 0.202 0.000 0.414 0.158 3.993 3.993 3.993 0.000 7.036 6.668 7.392 0.260 6.705 6.381 7.131 0.278
20 0.239 0.000 0.463 0.167 3.976 3.976 3.976 0.000 6.143 5.737 6.435 0.245 5.442 4.910 5.903 0.361
5 0.232 0.000 0.477 0.170 5.901 5.901 5.901 0.000 13.040 12.505 13.427 0.323 13.630 12.892 14.680 0.634
200 10 0.231 0.000 0.470 0.167 5.781 5.781 5.781 0.000 8.889 8.344 9.265 0.332 9.537 8.994 10.030 0.386
20 0.277 0.000 0.507 0.185 5.757 5.755 5.763 0.003 7.226 6.931 7.438 0.186 7.569 7.220 7.914 0.272
10 0.248 0.000 0.442 0.155 8.748 8.748 8.748 0.000 10.417 10.159 10.646 0.180 12.093 11.725 12.469 0.257
500
20 0.240 0.000 0.442 0.156 6.652 6.625 6.686 0.025 7.509 7.285 7.691 0.147 8.581 8.134 9.138 0.371
5 0.512 0.173 0.935 0.314 1.907 1.907 1.907 0.000 0.040 0.000 0.100 0.039 0.050 0.008 0.086 0.031
20 10 0.417 0.022 1.046 0.439 1.428 1.428 1.428 0.000 0.027 0.017 0.034 0.008 0.002 0.000 0.011 0.005
20 0.038 0.000 0.134 0.056 1.954 1.954 1.954 0.000 0.003 0.000 0.017 0.007 0.000 0.000 0.000 0.000
5 0.470 0.000 0.894 0.338 1.732 1.732 1.732 0.000 3.636 3.171 3.989 0.293 3.595 3.252 3.913 0.246
50 10 0.508 0.000 0.962 0.332 1.860 1.860 1.860 0.000 3.241 2.813 3.537 0.261 2.961 2.605 3.305 0.246
20 0.264 0.000 0.560 0.205 1.942 1.942 1.942 0.000 3.290 2.957 3.563 0.214 2.621 2.294 2.936 0.232
5 0.266 0.000 0.535 0.207 3.390 3.390 3.390 0.000 8.413 7.942 8.724 0.285 8.532 7.624 9.423 0.651
4
100 10 0.243 0.000 0.463 0.163 3.993 3.981 4.041 0.024 7.192 6.946 7.442 0.182 6.876 6.320 7.429 0.392
20 0.169 0.000 0.360 0.135 3.501 3.501 3.501 0.000 5.879 5.552 6.133 0.206 5.227 4.872 5.616 0.274
5 0.227 0.000 0.398 0.148 5.229 5.229 5.229 0.000 12.967 12.401 13.324 0.339 13.975 12.836 15.360 0.896
200 10 0.252 0.000 0.476 0.178 6.141 6.141 6.141 0.000 9.574 9.204 9.933 0.271 10.510 10.016 11.031 0.351
20 0.209 0.000 0.353 0.128 5.332 5.332 5.332 0.000 7.391 7.047 7.648 0.222 8.102 7.546 8.521 0.349
10 0.207 0.000 0.384 0.137 8.316 8.316 8.316 0.000 11.206 10.785 11.590 0.290 13.498 13.180 13.924 0.269
500
20 0.198 0.000 0.380 0.136 7.009 7.009 7.009 0.000 8.395 8.195 8.570 0.136 9.817 9.427 10.162 0.288
5 0.411 0.020 0.852 0.355 0.836 0.836 0.836 0.000 0.008 0.000 0.020 0.009 0.010 0.000 0.028 0.011
20 10 0.688 0.087 1.448 0.514 2.695 2.695 2.695 0.000 0.001 0.000 0.006 0.002 0.005 0.000 0.026 0.010
20 0.270 0.000 0.614 0.248 2.448 2.448 2.448 0.000 0.001 0.000 0.005 0.002 0.014 0.000 0.055 0.022
5 0.738 0.000 1.718 0.664 2.000 2.000 2.000 0.000 2.690 2.389 2.909 0.184 2.729 2.409 3.149 0.273
50 10 0.333 0.000 0.732 0.268 2.109 2.109 2.109 0.000 2.833 2.616 3.063 0.161 2.537 2.149 2.861 0.263
20 0.287 0.000 0.553 0.209 2.108 2.108 2.108 0.000 2.893 2.497 3.197 0.259 2.466 2.101 2.734 0.227
5 0.386 0.000 0.763 0.283 2.788 2.788 2.788 0.000 6.646 6.313 6.984 0.249 6.984 6.358 7.788 0.504
5
100 10 0.256 0.000 0.515 0.184 3.519 3.519 3.519 0.000 6.240 5.976 6.500 0.193 5.921 5.375 6.480 0.407
20 0.159 0.000 0.346 0.124 3.424 3.424 3.424 0.000 5.666 5.327 5.942 0.226 4.952 4.627 5.320 0.252
5 0.180 0.000 0.358 0.129 4.593 4.593 4.593 0.000 11.686 11.327 11.961 0.235 12.805 11.807 13.995 0.779
200 10 0.179 0.000 0.346 0.125 5.643 5.643 5.643 0.000 9.316 8.767 9.756 0.353 10.272 9.670 10.913 0.459
20 0.168 0.000 0.326 0.119 4.658 4.658 4.658 0.000 7.393 7.047 7.679 0.222 7.957 7.473 8.623 0.409
10 0.200 0.000 0.370 0.131 8.118 8.118 8.118 0.000 11.668 11.287 11.974 0.253 14.212 13.732 14.671 0.345
500
20 0.196 0.000 0.397 0.142 6.615 6.615 6.615 0.000 8.770 8.562 8.945 0.139 10.267 9.787 10.886 0.399
5 0.069 0.053 0.073 0.008 0.218 0.218 0.218 0.000 0.005 0.000 0.026 0.011 0.013 0.000 0.026 0.011
20 10 0.762 0.334 1.076 0.284 1.856 1.856 1.856 0.000 0.005 0.000 0.027 0.011 0.005 0.000 0.027 0.011
20 0.500 0.066 1.156 0.415 2.988 2.988 2.988 0.000 0.004 0.000 0.019 0.008 0.001 0.000 0.004 0.002
5 0.496 0.054 1.126 0.426 2.667 2.667 2.667 0.000 1.347 1.205 1.513 0.112 1.339 1.098 1.532 0.158
50 10 0.569 0.000 1.357 0.547 2.920 2.920 2.920 0.000 1.871 1.663 2.089 0.153 1.725 1.381 2.015 0.223
20 0.316 0.000 0.588 0.211 1.910 1.910 1.910 0.000 2.227 1.971 2.469 0.179 2.081 1.789 2.308 0.195
5 0.466 0.000 0.924 0.340 2.640 2.640 2.640 0.000 5.549 5.291 5.767 0.177 5.776 5.264 6.317 0.384
6
100 10 0.438 0.000 0.955 0.343 3.107 3.107 3.107 0.000 5.359 5.043 5.586 0.197 5.140 4.683 5.751 0.378
20 0.323 0.000 0.608 0.220 2.909 2.909 2.909 0.000 4.950 4.698 5.137 0.155 4.243 3.921 4.512 0.214
5 0.199 0.000 0.378 0.138 4.791 4.791 4.791 0.000 11.153 10.841 11.431 0.214 12.560 11.458 13.692 0.842
200 10 0.186 0.000 0.365 0.132 5.310 5.303 5.338 0.014 8.752 8.433 9.037 0.224 9.409 8.820 9.991 0.424
20 0.148 0.000 0.318 0.111 4.589 4.589 4.589 0.000 7.183 6.911 7.463 0.194 7.370 6.961 7.817 0.306
10 0.214 0.000 0.455 0.166 7.909 7.909 7.909 0.000 11.589 11.185 11.944 0.266 13.788 13.047 14.348 0.473
500
20 0.211 0.000 0.421 0.150 6.660 6.659 6.662 0.001 8.955 8.766 9.143 0.135 10.481 9.940 11.039 0.412
Mean 0.270 0.012 0.547 0.200 3.735 3.734 3.737 0.001 5.384 5.111 5.612 0.182 5.601 5.217 6.007 0.288

15
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. 7. Mean plot with 95% confidence interval for the interaction between the algorithms and F in large-scale problem.

Fig. 8. Mean plot with 95% confidence interval for the interaction between the algorithms and N in large-scale problem.

Table 11 performances of all algorithms little as the number of factories

Table 6 t-test with 95% confidence interval for DABC with CVNS, CRO, and ICG increases. That is, the fluctuate number of factories rarely affects
in large-scale problem.
the performances of the algorithms. In Fig. 8, the changes in the
Num Algorithm Mean ARPD t-value p-value IsDifferent
number of jobs greatly affect the algorithms. The ARPD values for
1 DABC-GVNS 0.270–3.74 −13.36 0.000 Yes
GVNS, CRO, and ICG increase rapidly as the number of jobs in-
2 DABC-CRO 0.270–5.38 −10.97 0.000 Yes
3 DABC-ICG 0.270–5.60 −10.19 0.000 Yes
creases. However, an increase in the number of jobs only slightly
affects the DABC. Similar trends can be seen in Fig. 9. In total, we
can conclude that the DABC proposed by us is significantly better
than the GVNS, CRO, and ICG algorithms for large-scale problems.
these algorithms, a two-sample t-test is executed, and the result
is given in Table 11. The p-values of DABC-GVNS, DABC-CRO, and 5. Conclusion and future works
DABC-ICG are all 0.000, which is less than 0.05. Therefore, the
DABC has a significant advantage when compared with the others In this paper, we study a novel the DNWFSP called DHNWFSP.
in terms of performance. The first consideration of this problem is the heterogeneity be-
Next, three mean plots with 95% confidence intervals for the tween factories in the field of the distributed flow shop schedul-
interactions between the algorithms and F, N, and M are given in ing. DHNWFSP studies have reduced the gap between theory and
Figs. 7–9 to intuitively demonstrate the effects of the algorithms. reality in terms of distributed scheduling. To solve the DHNWFSP
In general, the DABC has the lowest ARPD, GVNS has the second effectively, a discrete artificial bee colony algorithm is proposed.
lowest ARPD, and CRO and ICG have the highest ARPD values. The main contributions of the DABC are as follows: (1) The em-
This, the DABC works best in the large problems. In Fig. 7, the ployed bee phase and onlooker bee phase are designed according
16
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. 9. Mean plot with 95% confidence interval for the interaction between the algorithms and M in large-scale problem.

to four neighborhood search operators based on the problem CRediT authorship contribution statement
characteristics. (2) A speed-up method of inserting and swapping
neighborhood evaluations is proposed to accelerate the process Li Haoran: Conceptualization, Software, Validation, Writing -
of achieving the optimal solution. (3) A VND algorithm based original draft. Li Xinyu: Resources, Writing - review & editing.
on four local search methods for four neighborhood structures Gao Liang: Resources, Supervision.
is embedded into the scout bee phase to strengthen the local
search ability of the overall algorithm. The proposed algorithm Declaration of competing interest
is tested on small- and large-scale problems and compared with
several other state-of-art algorithms, such as the GVNS, CRO, and The authors declare that they have no known competing finan-
ICG algorithms. The results demonstrate the superiority of our cial interests or personal relationships that could have appeared
DABC in the DHNWFSP. In addition, the DABC can also migrate to to influence the work reported in this paper.
other types of DPFSPs, such as the original DPFSP, the DNIPFSP,
the DNWFSP, and the DBFSP. Acknowledgments
With regard to the managerial insights of this work, decision-
makers can easily access the newly designed model and the This research is supported by the National Natural Science
proposed DABC algorithm to optimize the makespan in a dis- Foundation for Distinguished Young Scholars of China (Grant No.
tributed heterogeneous no-wait flowshop. In real applications, 51825502), National Natural Science Foundation of China (Grant
heterogeneity brings greater difficulty to the process of pro- No. 51775216), and Program for HUST Academic Frontier Youth
duction management. With the globalization of production, the Team, China (Grant No. 2017QYTD04).
DHNWFSP model widely exists in the chemical processing in-
dustry [3], the food processing industry [4], the pharmaceuti- Appendix. Explanation of the speed-up methods for insertion
cal industry [5], and the steel industry [6]. Managers are faced within a factory
with tasks that require the allocation of batches of products to
multiple factories with different processing capabilities. Through One job in factory l is removed and then reinserted in the
the DABC, managers can solve the above types of scheduling same factory. Assume that 5 jobs are allocated to factory l. The
problems in various industries. Managers need to consider the completion time of factory l can be calculated as follows (see
transport times of the jobs assigned to the factory, the processing Fig. A.1).
times of the jobs in each factory, the factory characteristics and
so on. These parameters can affect the performance of the pro- Cmax (π l ) = r1 + dl,1,2 + dl,2,3 + dl,3,4 + dl,4,5 + tpl,5
posed DABC algorithm. Thus, it is necessary to select appropriate
The operation of insertion within the factory can be divided
algorithm parameters for a given practical problem. In addition,
into two steps, including removing the job and reinserting the
this algorithm can help managers effectively utilize the resources
job. According to the difference between the removal position
of various factories, but it requires the design of a reasonable
and the reinsertion position, different calculation formulas for the
process in each factory.
speed-up method of insertion within a factory are proposed.
Of course, there is much work to be done in future research.
Removing the job at position 1, the completion time can be
This paper only considers the heterogeneous DNWFSP. How-
calculated as follows (see Fig. A.2).
ever, many other types of distributed shop scheduling problems
′′
also possess heterogeneity. Therefore, one research direction is Cmax (π l ) = r1 + dl,1,2 + dl,2,3 + dl,3,4 + dl,4,5 + tpl,5 − dl,1,2
to study the heterogeneous DPFSP, DNIFSP, and DBFS. In real-
ity, most optimization problems are multiobjective optimization Removing the job at position nl , the completion time can be
problems, but a single objective is considered in this paper. calculated as follows (see Fig. A.3).
Therefore, another direction is that multiobjective or many- ′′
Cmax (π l ) = r1 +dl,1,2 +dl,2,3 +dl,3,4 +dl,4,5 +tpl,5 −dl,4,5 −tpl,5 +tpl,4
objective DHNWFSPs should be considered in the future.

17
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

Fig. A.1. Gantt of factory l. Fig. A.6. The Gantt of factory l after inserting job 3 in position nl .

Fig. A.2. The Gantt of factory l after removing the job at position 1. Fig. A.7. The Gantt of factory l after inserting job 3 in position 1 < j < nl .

− dl,1,2 + dl,1,3 + dl,3,2

Due to space limitations, other speed-up methods are similarly
available but are not described here.

Fig. A.3. The Gantt of factory l after removing the job at position nl . References

[1] B. Wang, K. Han, J. Spoerre, C. Zhang, Integrated product, process and

enterprise design: why, what and how? in: B. Wang (Ed.), BT - Integrated
Product, Process and Enterprise Design, Springer US, Boston, MA, 1997, pp.
1–20, http://dx.doi.org/10.1007/978-1-4615-6383-9_1.
[2] K.B. Kahn, G. Castellion, A. Griffin, The PDMA Handbook of New Product
Development, Wiley Hoboken, NJ, 2005.
[3] C. Rajendran, A no-wait flowshop scheduling heuristic to minimize
makespan, J. Oper. Res. Soc. 45 (1994) 472–478.
[4] N.G. Hall, C. Sriskandarajah, A survey of machine scheduling problems with
blocking and no-wait in process, Oper. Res. 44 (1996) 510–525.
Fig. A.4. The Gantt of factory l after removing the job at position 1 < j < nl .
[5] W.H.M. Raaymakers, J.A. Hoogeveen, Scheduling multipurpose batch pro-
cess industries with no-wait restrictions by simulated annealing, European
J. Oper. Res. 126 (2000) 131–151.
[6] T. Aldowaisan, A. Allahverdi, Minimizing total tardiness in no-wait
flowshops, Found. Comput. Decis. Sci. 37 (2012) 149–162.
[7] D. Shabtay, The just-in-time scheduling problem in a flow-shop scheduling
system, European J. Oper. Res. 216 (2012) 521–532.
[8] Z. Wang, W. Xing, F. Bai, No-wait flexible flowshop scheduling with no-idle
machines, Oper. Res. Lett. 33 (2005) 609–614.
[9] A. Che, M. Chabrol, M. Gourgand, Y. Wang, Scheduling multiple robots
Fig. A.5. The Gantt of factory l after inserting job 3 in position 1.
in a no-wait re-entrant robotic flowshop, Int. J. Prod. Econ. 135 (2012)
199–208.
[10] B. Naderi, R. Ruiz, The distributed permutation flowshop scheduling
problem, Comput. Oper. Res. 37 (2010) 754–768.
Removing the job at position 1 < j < nl , the completion time [11] S.-W. Lin, K.-C. Ying, Minimizing makespan for solving the distributed
can be calculated as follow. no-wait flowshop scheduling problem, Comput. Ind. Eng. 99 (2016)
202–209.
′′
Cmax (π l ) = r1 + dl,1,2 + dl,2,3 + dl,3,4 + dl,4,5 + tpl,5 − dl,2,3 − dl,3,4 + dl,2,4 [12] M.R. Garey, D.S. Johnson, R. Sethi, The complexity of flowshop and jobshop
scheduling, Math. Oper. Res. 1 (1976) 117–129.
[13] V. Fernandez-Viagas, J.M. Framinan, A bounded-search iterated greedy
To explain the insertion formula for the speed-up method of algorithm for the distributed permutation flowshop scheduling problem,
Int. J. Prod. Res. 53 (2015) 1111–1123.
insertion within a factory, the job in position 3 is removed (in
[14] S. Wang, L. Wang, M. Liu, Y. Xu, An effective estimation of distribution
Fig. A.4). The completion time is as follows. algorithm for solving the distributed permutation flow-shop scheduling
′′ problem, Int. J. Prod. Econ. 145 (2013) 387–396.
Cmax (π l ) = r1 + dl,1,2 + dl,2,4 + dl,4,5 + tpl,5 [15] H. Bargaoui, O.B. Driss, K. Ghédira, A novel chemical reaction optimiza-
tion for the distributed permutation flowshop scheduling problem with
Then, job 3 is inserted in position 1, and the completion time makespan criterion, Comput. Ind. Eng. 111 (2017) 239–250.
can be calculated as follows (see Fig. A.5). [16] R. Ruiz, Q.-K. Pan, B. Naderi, Iterated Greedy methods for the distributed
′ permutation flowshop scheduling problem, Omega 83 (2019) 213–222.
Cmax (π l ) = r1 + dl,1,2 + dl,2,4 + dl,4,5 + tpl,5 + dl,3,1 [17] T. Meng, Q.-K. Pan, L. Wang, A distributed permutation flowshop schedul-
ing problem with the customer order constraint, Knowl.-Based Syst. 184
Then, job 3 is inserted in position nl Or 1 < j < nl , and the (2019) 104894.
completion time can be calculated as follows (see Figs. A.6 and [18] M. Komaki, B. Malakooti, General variable neighborhood search algorithm
A.7). to minimize makespan of the distributed no-wait flow shop scheduling
problem, Prod. Eng. 11 (2017) 315–329.
′′
Cmax (π l ) = r1 + dl,1,2 + dl,2,4 + dl,4,5 + tpl,5 − tpl,5 + dl,5,3 + tpl,3 [19] W. Shao, D. Pi, Z. Shao, Optimization of makespan for the distributed
′′ no-wait flow shop scheduling problem with iterated greedy algorithms,
Cmax (π l ) = r1 + dl,1,2 + dl,2,4 + dl,4,5 + tpl,5 Knowl.-Based Syst. 137 (2017) 163–181.

18
H. Li, X. Li and L. Gao Applied Soft Computing Journal 100 (2021) 106946

[20] K.-C. Ying, S.-W. Lin, C.-Y. Cheng, C.-D. He, Iterated reference greedy [31] H. Rao, X. Shi, A.K. Rodrigue, J. Feng, Y. Xia, M. Elhoseny, X. Yuan, L.
algorithm for solving distributed no-idle permutation flowshop scheduling Gu, Feature selection based on artificial bee colony and gradient boosting
problems, Comput. Ind. Eng. 110 (2017) 413–423. decision tree, Appl. Soft Comput. 74 (2019) 634–642.
[21] K.-C. Ying, S.-W. Lin, Minimizing makespan for the distributed hybrid [32] Y.-F. Liu, S.-Y. Liu, A hybrid discrete artificial bee colony algorithm for
flowshop scheduling problem with multiprocessor tasks, Expert Syst. Appl. permutation flowshop scheduling problem, Appl. Soft Comput. 13 (2013)
92 (2018) 132–141. 1459–1463.
[22] G. Zhang, K. Xing, F. Cao, Discrete differential evolution algorithm for [33] M.F. Tasgetiren, Q.-K. Pan, P.N. Suganthan, A.H.L. Chen, A discrete artificial
distributed blocking flowshop scheduling with makespan criterion, Eng. bee colony algorithm for the total flowtime minimization in permutation
Appl. Artif. Intell. 76 (2018) 96–107. flow shops, Inf. Sci. (Ny). 181 (2011) 3459–3475.
[23] J.-H. Duan, T. Meng, Q.-D. Chen, Q.-K. Pan, An effective artificial bee colony [34] Q.-K. Pan, M.F. Tasgetiren, P.N. Suganthan, T.J. Chua, A discrete artificial
for distributed lot-streaming flowshop scheduling problem, in: Int. Conf. bee colony algorithm for the lot-streaming flow shop scheduling problem,
Intell. Comput, Springer, 2018, pp. 795–806. Inf. Sci. (Ny). 181 (2011) 2455–2468.
[24] Q.-K. Pan, L. Gao, L. Xin-Yu, F.M. Jose, Effective constructive heuristics [35] J. Li, Q. Pan, Solving the large-scale hybrid flow shop scheduling problem
and meta-heuristics for the distributed assembly permutation flowshop with limited buffers by a hybrid artificial bee colony algorithm, Inf. Sci.
scheduling problem, Appl. Soft Comput. 81 (2019) 105492. (Ny). 316 (2015) 487–502.
[25] D. Karaboga, An Idea Based on Honey Bee Swarm for Numerical Opti- [36] K. Peng, Q.-K. Pan, L. Gao, B. Zhang, X. Pang, An improved artificial
mization, Technical Report-tr06, Erciyes University, Engineering Faculty, bee colony algorithm for real-world hybrid flowshop rescheduling in
Computer, 2005. steelmaking-refining-continuous casting process, Comput. Ind. Eng. 122
[26] Y. Xue, J. Jiang, B. Zhao, T. Ma, A self-adaptive artificial bee colony (2018) 235–250.
algorithm based on global best for global optimization, Soft Comput. 22 [37] N. Sharma, H. Sharma, A. Sharma, Beer froth artificial bee colony algorithm
(2018) 2935–2952. for job-shop scheduling problem, Appl. Soft Comput. 68 (2018) 507–524.
[27] C. Ozturk, E. Hancer, D. Karaboga, Dynamic clustering with improved [38] T. Meng, Q.-K. Pan, H.-Y. Sang, A hybrid artificial bee colony algorithm for
binary artificial bee colony algorithm, Appl. Soft Comput. 28 (2015) 69–80. a flexible job shop scheduling problem with overlapping in operations, Int.
[28] D. Karaboga, B. Akay, A modified artificial bee colony (ABC) algorithm J. Prod. Res. 56 (2018) 5278–5292.
for constrained optimization problems, Appl. Soft Comput. 11 (2011) [39] J. Li, S.-C. Bai, P. Duan, H. Sang, Y. Han, Z. Zheng, An improved artificial
3021–3031. bee colony algorithm for addressing distributed flow shop with distance
[29] M. Sonmez, A.P. Akgüngör, S. Bektaş, Estimating transportation energy coefficient in a prefabricated system, Int. J. Prod. Res. (2019) 1–21.
demand in Turkey using the artificial bee colony algorithm, Energy. 122 [40] B. Qian, L. Wang, R. Hu, D.X. Huang, X. Wang, A DE-based approach to
(2017) 301–310. no-wait flow-shop scheduling, Comput. Ind. Eng. 57 (2009) 787–805.
[30] Z.H. Ding, M. Huang, Z.R. Lu, Structural damage detection using artificial [41] Q.-K. Pan, L. Wang, M.F. Tasgetiren, B.-H. Zhao, A hybrid discrete particle
bee colony algorithm with hybrid search strategy, Swarm Evol. Comput. swarm optimization algorithm for the no-wait flow shop scheduling
28 (2016) 1–13. problem with makespan criterion, Int. J. Adv. Manuf. Technol. 38 (2008)
337–347.

19