Artigo Heuristica Multi Objetivo

INTERNATIONAL
TRANSACTIONS
IN OPERATIONAL
Intl. Trans. in Op. Res. 27 (2020) 614–650 RESEARCH
DOI: 10.1111/itor.12662
An MO-GVNS algorithm for solving a multiobjective hybrid

flow shop scheduling problem
Eduardo Camargo de Siqueiraa , Marcone Jamilson Freitas Souzab and
Sérgio Ricardo de Souzac
a
Federal Institute of Education, Science and Technology of Triângulo Mineiro (IFTM), Paracatu, MG 38600-000, Brazil
b
Federal University of Ouro Preto (UFOP), Ouro Preto, MG 35400-000, Brazil
c
Federal Center of Technological Education of Minas Gerais (CEFET-MG), Av. Amazonas, 7675 – Nova Gameleira, Belo
Horizonte, MG 30510-000, Brazil
E-mail: eduardosiqueira@iftm.edu.br [de Siqueira]; marcone@ufop.edu.br [Souza]; sergio@dppg.cefetmg.br [de Souza]
Received 7 February 2018; received in revised form 22 November 2018; accepted 4 March 2019
Abstract
This paper addresses the multiobjective hybrid flow shop (MOHFS) scheduling problem. In the MOHFS
problem considered here, we have a set of jobs that must be performed in a set of stages. At each stage, we have
a set of unrelated parallel machines. Some jobs may skip stages. The evaluation criteria are the minimizations
of makespan, the weighted sum of the tardiness, and the weighted sum of the earliness. For solving it, an
algorithm based on the multiobjective general variable neighborhood search (MO-GVNS) metaheuristic,
named adapted MO-GVNS, is proposed. This work also presents and compares the results obtained by
the adapted MO-GVNS with those of four other algorithms: multiobjective reduced variable neighborhood
search, nondominated sorting genetic algorithm II (NSGA-II), and NSGA-III, and another MO-GVNS
from the literature. The results were evaluated based on the Hypervolume, Epsilon, and Spacing metrics, and
statistically validated by the Levene test and confidence interval charts. The results showed the efficiency of
the proposed algorithm for solving the MOHFS problem.
Keywords: multiobjective hybrid flow shop; MO-GVNS; HFS; multiobjective optimization; VNS
1. Introduction
Scheduling problems are common mainly in industrial production and consist of defining a sequence
of jobs to be performed on a set of machines, meeting one or more objectives. In this work, a
multiobjective scheduling optimization problem in a flow shop (FS) hybrid environment, with very
well known characteristics in real-world problems, is addressed. Some features of the approached
problem are the existence of unrelated parallel machines at each stage, due dates, tardiness and
earliness costs, eligibility machine and skip stages. In this problem, known in the literature as

C 2019 The Authors.
International Transactions in Operational Research
C 2019 International Federation of Operational Research Societies
Published by John Wiley & Sons Ltd, 9600 Garsington Road, Oxford OX4 2DQ, UK and 350 Main St, Malden, MA02148,
USA.
E.C. de Siqueira et al. / Intl. Trans. in Op. Res. 27 (2020) 614–650 615
multiobjective hybrid flow shop (MOHFS), we consider the objectives of minimizing the makespan,
the weighted sum of tardiness, and the weighted sum of the earliness. Its detailed description is
provided in Section 3.
Multiobjective optimization problems are characterized by involving two or more conflicting
objectives simultaneously. Therefore, it is not possible to find a single solution that optimizes all the
objectives at the same time. In other words, for this class of problems, the challenge is to seek a set
of efficient solutions, the so-called Pareto frontiers (Ehrgott, 2005). Ishibuchi et al. (2008) presented
a review of evolutionary multiobjective algorithms, pointing out the difficulty for solving problems
with many objectives using algorithms existing up to that date. To surpass these difficulties, Deb and
Jain (2014) proposed the nondominated sorting genetic algorithm III (NSGA-III). NSGA-III is a
genetic algorithm and represents an improvement of NSGA-II (Deb et al., 2002) for the treatment
of three or more objectives. NSGA-II, in turn, is an adaptation of its first version, NSGA, proposed
in Srinivas and Deb (1995). The selection process is based on the classification of dominance and
the crowding distance. In NSGA-II, this distance is calculated based on all points of the population,
and in NSGA-III it is calculated in relation to the reference points. Yuan et al. (2014) improved
NSGA-III including adaptive normalization and preservation of the diversity of reference points.
Algorithms based on multiobjective variable neighborhood search (MO-VNS) has been success-
fully applied for solving multiobjective combinatorial problems, since its first version proposed by
Geiger (2004). Schilde et al. (2009) extended the design of the variable neighborhood search (VNS)
method to the multiobjective case in order to plan tourist routes in a city. Liang et al. (2009) pre-
sented an MO-VNS algorithm to solve an identical parallel machine problem. Liang and Lo (2010)
developed an algorithm based on MO-VNS for solving the multiobjective redundancy allocation
problem. Arroyo et al. (2011) compared three multiobjective algorithms based on MO-VNS ap-
plied to the single machine scheduling problem with sequence-dependent setup times and distinct
due windows. Liang and Chuang (2013) addressed a biobjective resource allocation problem by
MO-VNS. Rego et al. (2014) applied MO-VNS for solving a biobjective single machine scheduling
problem in which the setup time depends on the sequence and job family. Gomes et al. (2014) applied
MO-VNS for solving a biobjective resource constrained project scheduling problem with precedence
relations. Duarte et al. (2015) presented an adaptation of three variants of the VNS metaheuristic for
solving multiobjective optimization problems, namely multiobjective reduced VNS (MO-RVNS),
multiobjective variable neighborhood descent (MO-VND), and MO-GVNS. These variants are
used to solve two multiobjective combinatorial optimization problems, that is, the multiobjective
knapsack problem and the multiobjective antibandwidth–cutwidth problem. The results showed
that the MO-GVNS variant was more efficient for solving the presented problems. This MO-GVNS
variant uses the MO-VND variant as local search, which alternates improvements in each objective
until no further improvements are found. According to the authors, at the end of the procedure, the
MO-VND ensures that each point in the solution has been improved with respect to each objective
function and each neighborhood of the handled problem. In Masri et al. (2019), a hybrid method
that uses MO-VNS for exploring and intensifying the search in specific regions is applied to solve
the single-path multicommodity communication flow problem. López-Sánchez et al. (2018) propose
four variants of a hybrid algorithm that combines greedy randomized adaptive search procedure
(GRASP) with variable neighborhood descent (VND) in multiobjective versions. The MO-VND is
used for improving the constructed solution generated by the multiobjective construction phase of
GRASP. These variants are used to solve a real-world waste collection problem.

C 2019 The Authors.
616 E.C. de Siqueira et al. / Intl. Trans. in Op. Res. 27 (2020) 614–650
Inspired by these successful MO-VNS applications, in this work we propose an adaptation of
the MO-GVNS algorithm presented in Duarte et al. (2015) for solving the addressed MOHFS
problem. As in Duarte et al. (2015), our adapted algorithm also uses MO-VND as the local search
method. However, while MO-VND proposed by those authors improves each objective function
separately, in our proposal the MO-VND method is used for improving all objective functions
simultaneously. In addition, as another important difference between our proposal and the one
presented in Duarte et al. (2015), the adapted MO-GVNS includes a second local search method,
which is an intensification procedure based on the Pareto dominance approach introduced in Arroyo
et al. (2011). The adapted MO-GVNS is compared to the MO-RVNS (our adapted MO-GVNS
without the local search), the original MO-GVNS from Duarte et al. (2015), NSGA-II, and NSGA-
III algorithms, outperforming all of them.
This paper brings two main contributions. The first one is the proposition of a new MO-VNS
variant, based on the MO-GVNS variant presented in Duarte et al. (2015). The second one is the
treatment of the MOHFS problem with three conflicting objectives. This situation is not commonly
discussed in the literature concerning this problem. It is important to note that an optimal solution
for the makespan is very efficient from a production point of view, but may be bad for the customer
who wants the service delivered without delays. On the other hand, an ideal solution for the
total weighted tardiness may satisfy the customer wishes but can be highly inefficient by decreasing
production capacity and increasing inventory costs. However, the best solution to the total weighted
earliness, in turn, may reduce inventory costs, but may increase the makespan or the tardiness
or both.
The remainder of the paper is outlined as follows. A literature review is presented in Section 2.
The machine environment, the characteristics and constraints of the problem, and the optimization
objectives are defined in Section 3. Sections 4 and 5 present the proposed algorithm and the
obtained results, respectively. Finally, Section 6 presents the conclusion and future prospects for the
development of this work.
2. Literature review
The mono-objective hybrid flow shop (HFS) problem is addressed in several works of the litera-
ture. Some of these papers are quoted below. Naderi et al. (2010) draw attention to two important
questions about HFS: the sequence determination at each stage and the distribution of jobs on the
machines at each stage. These authors present an algorithm based on the iterated local search (ILS)
metaheuristic, showed in Lourenço et al. (2003), to minimize makespan. Urlings and Ruiz (2010)
proposed genetic algorithms (Holland, 1975) to solve this HFS problem, with the characteristics
proposed by Ruiz et al. (2008), aiming at the minimization of makespan. Zandieh et al. (2010)
also worked with the same problem and proposed another genetic algorithm. In Defersha and
Chen (2012), the authors treat HFS with genetic algorithms on sequential and parallel computing
platforms. The tests showed that the parallel implementation greatly improved the computational
performance of the developed heuristics. In de Siqueira et al. (2013), an algorithm based on evo-
lutionary strategies is proposed to treat the HFS problem, also aiming at the minimization of
makespan. In these works, several characteristics of real problems are treated, as precedence con-
straints, time lags, and sequence-dependent setup times. In Dios et al. (2018), the HFS problem is

C 2019 The Authors.
approached, with particular attention with the issues of skip stages. The authors proposed a set of
constructive heuristics for minimizing makespan.
Other authors addressed the multiobjective flow shop (MO-FS) problems. Campos and Arroyo
(2014) proposed the application of NSGA-II, with local search, to solve a three-stage FS problem,
having the minimization of flowtime and total tardiness as objectives. A novel algorithm, called
restarted iterated Pareto greedy, is presented in Minella et al. (2011) and Ciavotta et al. (2013),
which is applied to the multiobjective permutation FS problem with sequence-dependent setup. The
same problem is addressed in Li and Li (2015) by means of local search based on decomposition,
and in Li and Ma (2016), by memetic algorithms. Minella et al. (2008) brings an assessment of
multiobjective optimization algorithms for FS problems. In Torkashvand et al. (2017), an MO-FS
problem is approached, in which there are two sets of jobs and each one with its own purpose. The
objectives considered are the minimization of makespan and the minimization of total tardiness.
The authors developed a new method based on biogeography and the results showed that the pro-
posed algorithm outperforms the other algorithms in the literature. In Wang and Tang (2017), a
multiobjective machine learning based multiobjective memory algorithm is proposed for a multi-
objective permutation FS problem. Three objectives were considered: minimization of makespan,
minimization of total flowtime, and minimization of total tardiness. The results showed that the
algorithm improves several results in the literature. Xu et al. (2017) proposed an algorithm based
on the multiobjective ILS (MO-ILS) to solve a multiobjective permutation FS problem in order
to minimize the makespan and the weighted sum of the tardiness. The algorithm was compared
with several evolutionary algorithms and surpassed the results of all them. Deng and Wang (2017)
proposed a memetic algorithm to solve an MO-FS problem in order to minimize the makespan
and the total tardiness. Gong et al. (2018) addressed a blocking MO-FS problem and presented
a hybrid artificial bee colony algorithm to solve two conflicting objectives: the makespan and the
earliness time. In Lu et al. (2017), an MO-FS problem with sequence-dependent setup and control-
lable transportation time is investigated. The problem considers both makespan and consumption
of setup and is solved by a hybrid backtracking search algorithm.
Some works from the literature treating the case of MOHFS problems with two objectives are
reviewed in the following. Behnamian et al. (2009) implemented a three-phase metaheuristic to solve
an MOHFS problem with identical machines at each stage and with setup times. In Dugardin et al.
(2010) a new algorithm, called L-NSGA, is presented, in which the Pareto dominance relationship
is replaced by the Lorenz dominance relationship (Kostreva and Ogryczak, 1999; Kostreva et al.,
2004). The authors compared the results obtained with those found by complete enumeration and
adaptations of the NSGA-II and Strength Pareto Evolutionary Algorithm 2(SPEA2) algorithms,
the latter proposed by Zitzler et al. (2002). Asefi et al. (2014) solved an MOHFS problem by applying
an approach that combines the characteristics of the NSGA-II and the VNS metaheuristic for the
minimization of both makespan and average tardiness. Already in Ying et al. (2014), an algorithm
based on iterated Pareto greedy is applied to solve the MOHFS problem to minimize the makespan
and total tardiness. Chamnanlor et al. (2017) addressed the minimization of makespan in an MO-
HFS problem with time window constraints, and for solving it they proposed a hybrid algorithm
that combines genetic algorithms and ant colony optimization (Dorigo and Stützle, 2004) methods.
The results showed great efficiency of the proposed algorithm. Wang et al. (2017) proposed a multi-
objective memory algorithm to solve an MOHFS problem. The objectives are to minimize the total
flowtime and the number of overdue jobs. Li et al. (2018) proposed a multiobjective optimization

C 2019 The Authors.
algorithm called energy aware for solving MOHFS problems. Two objectives are considered simul-
taneously: the minimization of makespan and the minimization of setup consumption. Mousavi
et al. (2018) focused on an MOHFS problem, addressed a biobjective MOHFS problem, having as
objectives to minimize makespan and the sum of tardiness. The solution method developed is based
on genetic algorithms. To validate the proposed algorithm, a complete enumeration algorithm is
used to find the Pareto frontier for small problems. The results showed that the proposed algorithm
is efficient. Pargar et al. (2018) studied the effect of learning techniques on an MOHFS problem with
two conflicting objectives: makespan and total tardiness. In de Siqueira et al. (2018), an algorithm
based on MO-VNS is proposed for solving the MOHFS problem with two minimization objectives:
the makespan and weighted sum of tardiness.
Very few articles dealing with the MOHFS problem with three conflicting objectives are found
in the literature. Marichelvam and Geetha (2014) addressed a multistage MOHFS with identical
parallel machines to minimize makespan, flowtime, and machine idle time, using a discrete firefly
algorithm (Yang, 2010). Xu et al. (2016) proposed an improved multiobjective artificial bee colony
algorithm, based on an adaptive neighborhood search method, for solving the HFS scheduling
problem with unrelated parallel machines. The three objectives to be minimized were the makespan,
total weighted earliness/tardiness, and total waiting time. Lei and Zheng (2017) addressed the MO-
HFS problem with three objectives to minimize total tardiness, maximum tardiness, and makespan.
The authors adopted a prioritization methodology of the three objectives considered. Thus, the
problem solved is reduced to a biobjective problem, since only the first two are effectively treated.
They proposed a new method of local search called neighborhood structures and global exchange.
The results showed that the proposed algorithm is competitive when compared to other algorithms
of the literature as multiobjective tabu search (Wang and Liu, 2014) and NSGA-II. Li et al. (2017)
presented a local search enhanced hybrid artificial bee colony algorithm (Li et al., 2011) for solv-
ing the multiobjective flexible task scheduling problem in a cloud computing system, modeled as
an MOHFS problem. The authors tackled the optimization of three objectives simultaneously:
minimum of the makespan, maximum workload, and maximum of the total workload.
3. Problem characterization
In the MOHFS problem under consideration, let N = {1, 2, 3, . . . , n} be a set of jobs that must
be performed in a set of stages M = {1, 2, 3, . . . , m}. For each stage i, there is a set of unrelated
parallel machines. Some jobs can skip stages and this is an important property of this problem. The
processing of job j on stage i is called a task. A common situation in practice is addressed, in which
some jobs can only be performed in certain specialized machines, which, in turn, can only perform
a certain job group. The main characteristics of the problem are:
(i) Fj : set of stages visited by job j, 1 < |Fj | < m;

(ii) pil j : processing time of job j in machine l and stage i;
(iii) Gi j : set of eligible machines for the job j at stage i;
(iv) d j : due date for job j;
(v) w j : weight for tardiness of the job j;
(vi) u j : weight for earliness of the job j.

C 2019 The Authors.
Table 1
Data for machine eligibility—Example 1
i 1 2
j 1 {1,2} {4}
2 {1,2} {3}
3 – {3,4}
4 {2} {3,4}
5 {1, 2} –
Items (i)–(iii) indicate that the machines available in each phase are independent. Furthermore,
some jobs can skip stages, which is very common in various industrial processes. If a step in a
production process is a bottleneck, managers often add machines parallel to this step in order to
decrease the bottleneck. These machines are usually different from each other and some do not
perform all the jobs. In the same way, some special products can skip process steps. The items
(iv)–(vi) consider another situation found in practice, where products have desirable delivery times.
If the job ends after the deadline, there is a cost that is typically related to the contractual fines;
on the other hand, if the job ends before the deadline, the cost typically refers to the storage of the
products. Stocking costs are generally lower than the tardiness penalty amounts.
The following objectives are considered in the current paper:
(i) makespan minimization (Cmax );

(ii) minimization of the weighted sum of tardiness ( w j T j );
(iii) minimization of the weighted sum of earliness ( u j E j ).
The completion time C j of a job j is the instant in which the last task of this job is completed. The
makespan Cmax , in turn, is the completion time of the last system task, that is, Cmax = max j∈N {C j }.
The tardiness T j of a job is defined as max{(C j − d j ), 0}. In addition, the earliness of a job is defined
as max{(d j − C j ), 0}. Each job is associated with a tardiness weight w j and with a earliness weight
u j . These weights reflect the importance of the own job and the possible delays and anticipations
that have occurred.
In de Siqueira et al. (2016), the same problem is addressed, considering, however, only the first two
objectives, without taking into account the influence of the earliness of the jobs in the increase of the
makespan and the tardiness. For a better understanding regarding the importance of considering
these three objectives simultaneously, an example is given below.
Example 1. Consider an instance with five jobs and two stages, with two machines at each stage.
Table 1 shows which machines l are eligible for each job j in each stage i. From this table, we
could verify, for example, that job 1 could be performed on machines 1 and 2 at stage 1 and on
machine 4 at stage 2. We could also verify that jobs 1, 2, and 4 visit all stages, while job 3 skips
stage 1.
Table 2 shows the processing time (pil j ) of each job j at each machine l and at each stage i. In
this table, we conclude that the processing time of job 1 at machine 2 and stage 1 is 8 time units.
The processing time of a job in a noneligible machine is null. Table 2 also shows the due date (d j )

C 2019 The Authors.
Table 2
Processing time, due date d j , tardiness weight w j , and earliness weight u j —
Example 1
i 1 2
l 1 2 3 4 dj wj uj
j 1 10 8 0 21 35 4 2
2 13 15 45 0 60 3 1
3 0 0 15 22 48 1 1
4 0 31 17 12 51 4 3
5 17 29 0 0 30 5 5

Fig. 1. GANTT diagram—Example 1. Cmax = 65; w j Tj = 61; u j E j = 23.
and the weights w j and u j by tardiness and by earliness, respectively, of each job j. From this table,
the due date of job 4 is d4 = 51, the tardiness weight is w4 = 5, and the earliness weight is u4 = 3.
Figure 1 shows a possible sequence for this example. Note that the makespan for this sequence is
65 time units and the weighted sum of tardiness is equal to 61 (= w3 T3 + w4 T4 = 1 × 5 + 4 × 14).
The weighted sum of earliness is given by 23 (= u1 E1 + u5 E5 = 2 × 4 + 5 × 3).
The previous example shows various characteristics of the problem. To show that the objectives
are conflicting, another example will be presented.
Example 2. Let there be an instance with four jobs and three stages, with one machine at each stage.
In this example, for simplicity, a more specific case will be considered, in which there is only one
permutation of jobs for all stages. In addition, all jobs go through all stages and all machines are
eligible for all jobs.
Table 3 shows the processing time (pil j ) of each job j in each machine l and in each stage i. This
table also shows the due date (d j ) and the weights w j and u j for tardiness and earliness, respectively,
of each job j. In this table, it can be verified that the processing time of job 1 is 6 units in the three
machines. From this table, it can also be verified that the due date of job 2 is d2 = 45 and its weights
by delay and anticipation are w2 = 5 and u2 = 3, respectively.

C 2019 The Authors.
Table 3
Processing time, due date d j , tardiness weight w j , and earliness weight u j —
Example 2
i 1 2 3
l 1 2 3 dj wj uj
j 1 6 6 6 32 3 1
2 9 12 6 45 5 3
3 15 18 3 40 10 2
4 12 15 15 73 2 1

Fig. 2. GANTT diagram—Example 2—Case 1. Cmax = 81; w j Tj = 115; u j E j = 2.
First, the permutation [3, 1, 2, 4] will be considered. The sequencing for this solution is schema-
in Fig. 2. This solution produces a makespan of Cmax = 81, the weighted sum of tardiness
tized
is w j T j =115 (= w1 T1 + w2 T2 + w4 T4 = 3 × 13 + 5 × 12 + 2 × 8) and the weighted sum of the
earliness is u j E j = 2 (= u3 E3 = 1 × 2).
From the configuration presented, the permutation that produces the smallest makespan is
[1, 2, 4, 3]. Figure
3 shows the sequencing for the solution
presented. For this solution, we have
Cmax = 63, w j T j = 230 (= w3 T3 = 10 × 23), and u j E j = 13 (= u4 E4 = 1 × 13). Thus, it may
be noted that by minimizing makespan, both tardiness and earliness have been compromised.
The same permutation will now be considered, but job 4 will be shifted to be finished exactly
on its due date. For this, job 3 will also be shifted, and thus delaying its delivery. This situation
is illustrated in Fig. 4. This change produced a makespan
of Cmax = 76, that is, an increase of
almost 21%; the weighted sum of tardiness became w j T j = 360 (= w3 T3 = 10 × 36), that is, an
increase of more than 55%; and the weighted sum of earliness is 0, since no job was delivered ahead
of time.
Situations like these show that minimizing one criterion can seriously compromise the other
two. This means that the objectives are strongly conflicting, so it is necessary to study and apply
multiobjective optimization techniques in order to find compromise solutions.

C 2019 The Authors.


4. The proposed MO-GVNS algorithm
This section presents the proposed MO-GVNS algorithm for solving the MOHFS problem. It is
organized as follows. The next subsection introduces the general pseudo-code of this algorithm. In
Subsection 4.4, it is explained how the jobs are sequenced in the machines. Subsection 4.5 specifies
the types of moves that are used to explore the solution space. In Subsections 4.6 and 4.7, the
MO-VND and local search algorithms are detailed, respectively.
4.1. The proposed MO-GVNS algorithm
For solving MOHFS, an algorithm based on the MO-GVNS metaheuristic (Duarte et al., 2015)
is proposed. MO-GVNS is a multiobjective version for the VNS (Mladenović and Hansen,

C 2019 The Authors.
1997; Hansen et al., 2008). The version proposed in the current paper will be called adaptive
MO-GVNS, considering the modifications included in the original version of the MO-GVNS
algorithm.
The proposed algorithm differs from the original metaheuristic algorithm of Duarte et al.
(2015) at four points. First, the initial generation of the adapted MO-GVNS is done through
a partially greedy constructive method, whereas in Duarte et al. (2015) the initial solutions
are built randomly. Second, another difference is that the local search of the original algo-
rithm works with one objective at a time, while adapted MO-GVNS works with all objectives
simultaneously. Third, in addition, as another important difference between our proposal and
the one posed in Duarte et al. (2015), the adapted MO-GVNS includes a second local search
method, which is an intensification procedure based on the Pareto dominance approach intro-
duced in Arroyo et al. (2011). Fourth, furthermore, a new method of job assignment is also
proposed.
The pseudo-code of the adapted MO-GVNS is shown in Algorithm 1. The algorithm receives
as parameters the maximum size (sizeMax) of the set of nondominated solutions; the maximum
level (levelMax) of perturbation; and the stopping criterion. First, at Lines 1–4, the initial solutions
s are generated by the construction phase of the GRASP method (Subsection 4.3), if they are
nondominated solutions. The procedure for verifying and inserting a nondominated solution into
the set D is called addSolution and is showed in Algorithm 2. Since, as shown in Subsection 4.2, a
solution is a job permutation, the initial solutions consist of permutations of these jobs. When a new
solution is generated, the job allocation method is executed; this method is detailed in Subsection
4.4. After that, the variable level is initialized at Line 5. In the following, the algorithm goes into its
main loop, between Lines 6 to 18.
Algorithm 1. Adapted MO-GVNS

Require: sizeMax, levelMax, Stopping Criterion
1: for k ← 1 to sizeMax do
2: s ← generateGRASPSolution();
3: addSolution(D, s)
4: end for
5: level ← 1
6: repeat
7: Select a random neighborhood Ni
8: D ← Perturbation(D, level, Ni )
9: D ← Adapted MO-VND(D )
10: f lag ← f alse
11: f lag ← addSolution(D, D )
12: if f lag = f alse then
13: level ← level + 1
14: end if
15: if level > levelMax then
16: level ← 1
17: end if
18: until Stopping Criterion to be satisfied
Ensure: D;

C 2019 The Authors.
Fig. 5. Representation of a solution s.
Algorithm 2. addSolution
Require: s, D
1: if solution s is nondominated in D then
2: Insert s in D
3: end if
Ensure: D;
At each iteration of this main loop, one of the neighborhoods described in Subsection 4.5 is
selected (Line 7). Subsequently, the perturbation procedure (Line 8), described in Subsection 4.8, is
applied. The result of this perturbation procedure is a new set D of nondominated solutions. This
set goes through the local search procedure adapted MO-VND (Line 9), described in Subsection
4.6. The result of the local search is a new set D , possibly different from D .
If there is an improvement in the set D when compared to the set D, that is, if there is at
least one nondominated solution in the new set D that is not present in the old set D , then
the value of the variable level remains the same; otherwise, it is incremented by one unit, thereby
increasing the perturbation intensity of the solutions. If the variable level reaches its maximum
value, it is reset and takes its lowest value (Line 15). The procedure addSolution (Line 11) compares
the two sets, adds the nondominated solutions and excludes the dominated solutions from the first
set. This procedure returns “true” if there is any solution in the initial set and returns “false,”
otherwise.
The procedure continues until the stopping criterion is satisfied, and then the set of nondominated
solutions D is returned. The next subsections explain each of the modules of the proposed algorithm.
4.2. Representation of a solution
A solution s of the problem is represented by a vector. Each position of this vector indicates the
order in which each job is executed. Figure 5 illustrates the representation of a solution. In this
figure, for example, it is shown that the first job to be performed is job 1; then jobs 2, 5, 3, and 4 are
executed, in this order. This solution represents the scheduling shown in Fig. 1 of Section 3. This
representation is simple but efficient due to the characteristics of the HFS problem, in which the
sequence executed by the first stage interferes in the processing of the following stages.
4.3. Initial solutions
For generating initial solutions, an algorithm based on the construction phase of the GRASP
metaheuristic (Feo and Resende, 1995) was adapted.

C 2019 The Authors.
The construction of solutions works as follows. For each position of the solution vector s, one of
the following three criteria is chosen randomly: (a) shortest processing time, (b) lowest due date, and
(c) greatest due date. Each of these criteria privileges one of the approached objective functions: (a)
makespan, (b) tardiness, and (c) earliness, respectively. According to the criterion chosen, the job
with the best evaluation is inserted into a restricted candidate list (RCL) given by

RCL = j ∈ J | gm ( j) ≤ gmmin + α gmmax − gmmin ,
where gm is the evaluation function of the chosen criterion, J is the set with all jobs that are not yet
sequenced, and gmmax and gmmin are, respectively, the maximum and minimum values of the evaluation
function in relation to the criterion chosen applied to the job j ∈ J. After this, a job is chosen at
random from the RCL list and inserted into the vector s. The parameter α controls the randomness
of the procedure, so that the greater the value of α, the more random the method is presented. These
steps are repeated until all jobs are sequenced.
4.4. Job assignment
In Algorithm 1, whenever a new solution is generated, the procedure that assigns the jobs to the
respective machines is executed and calculates the values of Cmax , w j T j , and u j E j . This job
assignment procedure in the machines of the respective stages is shown in Algorithm 3 and works
as follows.
Algorithm 3. Job assignment

Require: s
1: s ← updateSolution(s)
2: for each stage i do
3: for k ← 1 to n do
4: j ← sk
5: if i ∈ Fj then
6: Select a machine l of the stage i in which the job j finishes early, such that l ∈ Gi j .
7: Sequence the job j in the next free position of the machine l.
8: end if
9: end for
10: s ← updateSolution(s )
11: end for
12: Calculate Cmax , w j Tj and u j E j .

Ensure: Cmax , w j Tj , u j E j ;
The method receives a solution s as input parameter. At Line 1, this solution is updated with the
procedure updateSolution. Given a sequence of jobs s = (. . . , a, b, . . .), the updateSolution procedure
shifts two subsequent jobs so that the first job visits fewer future stages than the second. Thus,
this procedure, after this application, returns another sequence s = (. . . , b, a, . . .) satisfying this
condition. In order to avoid the growth of the tardiness value and very drastic changes, this exchange
is not performed if the completion time of the first job in the last stage visited is greater than its due

C 2019 The Authors.
Fig. 6. Types of moves.
date. In addition, it is important to be clear that each job participates in this exchange only once
for each stage.
After the initial vector update, for each stage i (Lines 2–11) and at each position k of the vector
s (Lines 3–9), the job placed at the k position, if it visits the i stage, is executed by the machine
that can finish it as soon as possible, among the eligible machines. After performing all the tasks,
the vector s is updated by the updateSolution method (Line 10). The procedure continues until all
stages are considered. Finally, the values of Cmax , w j T j , and u j E j are calculated and returned.
4.5. Neighborhood structures
Four types of moves are used to explore the solution space, each defining a neighborhood structure,
in this order.
(a) Insert: consists of changing the position of a job. Figure 6(a) illustrates the insertion of job 2 to
a new position in the sequence (in this case, after job 3).
(b) Exchange: consists of exchanging the position of two jobs among themselves. Figure 6(b)
illustrates the exchange between jobs 1 and 3, that is, job 1 occupies the position of job 3 and,
in its turn, job 3 takes the position of job 1.
(c) Inversion: consists of reversing the order of job in a certain interval. Figure 6(c) shows the
inversion of the sequence of execution of the jobs comprised between jobs 2 and 4, including
these latter; in this case, the sequence in this interval was 2, 5, 3, and 4, and, after this move,
became 4, 3, 5, and 2.

C 2019 The Authors.
(d) Scramble: consists of random mixing the order of all jobs within a certain interval. This type of
move is used only for perturbation. In this move, at first, two different jobs are randomly chosen;
then, at second, jobs that are in the range between them (included) are scramble. Therefore,
the size of the interval can vary from 2 to n (n is the number of jobs). Figure 6(d) shows the
scramble of the jobs in the interval between jobs 2 and 4.
4.6. Adapted MO-VND procedure
Algorithm 4 shows the adapted MO-VND method, used as a local search operator for the adapted
MO-GVNS metaheuristic presented in Algorithm 1. The adapted MO-VND proposed receives
an initial set D of nondominated solutions as a parameter and performs a systemic search in
the neighborhood of these solutions using two local search methods, namely LocalSearch-r and
Arroyo-LocalSearch. LocalSearch-r method performs the search with the first three types of moves
presented in Subsection 4.5: (a) insert, (b) exchange, and (c) inversion. Arroyo-LocalSearch method
is proposed in Arroyo et al. (2011). Both local search methods are described in Subsection 4.7.
Algorithm 4. Adapted MO-VND

Require: D
1: r ← 1
2: repeat
3: if r < 3 then
4: D ← LocalSearch-r(D)
5: else
6: D ← Arroyo-LocalSearch(D)
7: end if
8: f lag ← addSolution(D, D )
9: if f lag = f alse then
10: r←r+1
11: else
12: r←1
13: end if
14: until r = 5
Ensure: D;
Some details in the following show how Algorithm 4 works. Initially, at Line 1, the first neigh-
borhood is defined by the insert and exchange moves (r = 1). Dubois-Lacoste et al. (2009) showed
that the union of insert and exchange moves is more efficient in multiobjective local search than
used separately to solve FS problems. After this, the local search process is repeated until all the
considered neighborhoods have been explored. In this process, if r = 1, the local search is applied
considering the insert and exchange moves; and if r = 2, the inversion move is applied as local
search. Algorithm 5 presents how these local search operators are applied. On the other hand, if
r = 3, then the Arroyo-LocalSearch method is the local search action to be executed. Algorithm 6
shows the pseudo-code of this method. At Line 8 similar to Algorithm 1, the procedure addSo-
lution verifies whether there has been improvement in the set D. If there is no addition of new

C 2019 The Authors.
nondominated solutions, then the value of r is incremented, and the algorithm explores a new
neighborhood; otherwise, the value of r returns to its minimum value, that is, r = 1.
4.7. Local search algorithms
This subsection presents the two local search methods used to improve the solutions. The first
method, given by Algorithm 5, and named here LocalSearch-r, is shown in Algorithm 4 and
explained in Subsection 4.6. This method applies only one of the following moves during the entire
local search: (a) insert, (b) exchange, and (c) inversion. The idea of this method is based on the
local search proposal by Paquete et al. (2004). The value of the variable r defines the applied move.
That is, if r = 1, then the improvement is performed by the insert and exchange moves; if r = 2,
the improvement is performed by the inversion move. The second method of local search, here
named Arroyo-LocalSearch and presented in Algorithm 6, consists of applying the intensification
procedure proposed by Arroyo et al. (2011), which is, in its turn, based on the Iterated greedy search
method proposed by Ruiz and Stützle (2007). These two methods are described in the sequel.
Algorithm 5 shows the pseudo-code of the LocalSearch-r method. This method starts by selecting
a solution s from the set D of nondominated solutions (Line 2). This solution is inserted into a new
set Y (Line 3). After that, the algorithm goes into a loop (Lines 4–8). At each iteration of this loop,
an unvisited solution of the set Y is selected and all neighbors of s are generated with the move r. All
these neighbors will form a new set Y and, if there is an improvement in that set when compared
to the set Y , then the procedure is repeated; otherwise, the variable flag assumes the value false and
the loop is interrupted. At the end of this loop, the set Y is added to the set D with the procedure
addSolution. All of these steps are repeated until all solutions belonging to D are visited, and thus
set D is returned by the local search.
Algorithm 5. LocalSearch-r
Require: D
1: repeat
2: Select an unvisited solution s belonging to D
3: Y ← {s}
4: repeat
5: Select an unvisited solution s belonging to Y
6: Y ← Set of all s neighbors-r
7: f lag ← addSolution(Y, Y )
8: until f lag = f alse
9: addSolution(D, Y )
10: until Unvisited Solutions D = ∅
Ensure: D;
Algorithm 6 describes the Arroyo-LocalSearch method. This method begins by selecting a solution
s from the set D of nondominated solutions (Line 1). Then p jobs are removed from this solution
and inserted into a set X (Line 2). The partial sequence v generated by the removal of p jobs from
solution s is inserted into a new set Y (Line 3). For each job removed from solution s initially

C 2019 The Authors.
selected (and now contained in the X set), a set Y is created, and, for each partial solution v
belonging to the set Y , the job j ∈ X is inserted into all positions of v, thus generating a new set
Y with (n − p + j) sequences resulting from each insertion. The set Y is added to the set Y with
the addSolution procedure (Line 8). At the end of the second loop, the set Y receives the set Y
(Line 10). The algorithm returns the set Y at the end of the procedure.
Algorithm 6. Arroyo-LocalSearch
Require: D
1: Select a solution s belonging to D
2: v ← Remove at random p jobs from s and insert these jobs in a set X , that is, v is a partial sequence with n − p jobs
3: Y ← {v}
4: for j ← 1 to p do
5: Y ← ∅
6: for each partial sequence v ∈ Y do
7: Insert job j ∈ X in all positions of v generating a set Y of (n − p + j) sequences
8: addSolution(Y , Y )
9: end for
10: Y ← Y
11: end for
Ensure: Y ;
4.8. Perturbation procedure
The perturbation procedure, included at Line 8 of Algorithm 1, is shown in Algorithm 7. This

procedure consists of applying the chosen move in all solutions of the set D during level times.
Therefore, if level assumes the value 2, then the chosen move is applied two times. All the jobs
involved in this procedure are chosen randomly.
Algorithm 7. Perturbation
Require: D, level, Ni
1: D ← ∅
2: for each solution s ∈ D do
3: for q ← 1 to level do
4: Apply to s a random move from Ni
5: end for
6: addSolution(D , s)
7: end for
Ensure: D ;
5. Computational results
This section shows the results obtained by the execution of the proposed adapted MO-GVNS
algorithm. Subsection 5.1 shows the metrics used to evaluate the solution sets and explains how to

C 2019 The Authors.
Table 4
Parameter settings for MO-GVNS2, NSGA-II, and NSGA-III
Algorithm MP Level P pc pm Nr
MO-GVNS2 3 – – – –
NSGA-II – 80 0.85 0.05 –
NSGA-III – 100 0.85 0.05 15
Table 5
Average values for the Hypervolume metric for small instances (n ∈ {5, 7, 9, 11, 13, 15})
Algorithm n=5 n=7 n=9 n = 11 n = 13 n = 15

MO-GVNS1 0.80 0.86 0.85 0.89 0.89 0.85
MO-GVNS2 0.77 0.82 0.78 0.79 0.78 0.75
MO-RVNS 0.59 0.60 0.50 0.47 0.44 0.35
NSGA-III 0.72 0.77 0.69 0.72 0.70 0.65
NSGA-II 0.36 0.30 0.25 0.20 0.19 0.19
Table 6
Average values for the Epsilon metric in small instances (n ∈ {5, 7, 9, 11, 13, 15})

MO-GVNS1 0.17 0.10 0.09 0.08 0.08 0.09
MO-GVNS2 0.20 0.14 0.15 0.15 0.15 0.15
MO-RVNS 0.31 0.30 0.36 0.39 0.42 0.48
NSGA-III 0.23 0.17 0.21 0.19 0.20 0.20
NSGA-II 0.53 0.53 0.55 0.58 0.58 0.58
Table 7
Average values for the Spacing metric (%) in small instances (n ∈ {5, 7, 9, 11, 13, 15})

MO-GVNS1 4.49 1.37 0.76 0.67 0.44 0.46
MO-GVNS2 5.08 1.97 1.29 1.06 0.88 0.66
MO-RVNS 6.45 2.74 2.74 2.43 2.26 1.52
NSGA-III 5.83 3.99 3.39 2.92 2.24 2.32
NSGA-II 4.10 2.51 2.25 1.94 1.25 1.37
Table 8
Average values for the Hypervolume metric in large instances (n ∈ {50, 100, 150, 200})
Algorithm n = 50 n = 100 n = 150 n = 200

MO-GVNS1 0.80 0.81 0.81 0.80
MO-GVNS2 0.73 0.75 0.71 0.73
MO-RVNS 0.61 0.65 0.65 0.64
NSGA-III 0.17 0.22 0.22 0.21
NSGA-II 0.03 0.07 0.08 0.08

C 2019 The Authors.
Table 9
Average values for the Epsilon metric in large instances (n ∈ {50, 100, 150, 200})
Algorithm n = 50 n = 100 n = 150 n = 200

MO-GVNS1 0.14 0.13 0.13 0.13
MO-GVNS2 0.20 0.18 0.19 0.19
MO-RVNS 0.28 0.28 0.29 0.34
NSGA-III 0.66 0.66 0.58 0.58
NSGA-II 0.87 0.86 0.79 0.79
Table 10
Average values for the Spacing metric (%) in large instances (n ∈ {50, 100, 150, 200})
Algorithm n = 50 n = 100 n = 150 n = 200

MO-GVNS1 0.03 0.05 0.11 0.09
MO-GVNS2 0.04 0.07 0.12 0.09
MO-RVNS 0.19 0.23 0.48 0.32
NSGA-III 0.34 0.39 0.58 0.47
NSGA-II 0.23 0.27 0.35 0.36
Fig. 7. Confidence interval for the Hypervolume metric: small instances.

C 2019 The Authors.
Fig. 8. Confidence interval for the Hypervolume metric: large instances (n = 50).
calculate them. In Subsections 5.2 and 5.3, the preliminary and final tests are presented, respectively.
Subsection 5.4 shows a comparison between the results produced by the proposed algorithm with
the ones produced by others algorithms presented in the literature. In the following, Subsection 5.5
introduces a statistical analysis of the obtained results. Finally, Subsection 5.6 brings a discussion
of the results achieved by the proposed algorithm.
The adapted MO-GVNS algorithm, introduced in Algorithm 1, was implemented in C++, using
the IDE Netbeans 6. The computational tests were performed on an Intel Core i7 processor, 2.00
GHz, with 16 GB of RAM memory, under Linux Ubuntu 64 bits operating system.
The set of instances used in the experiments were adapted from Urlings (2011, 2010). The original
test problems provided by this author did not contain penalties in earliness. Therefore, we included
penalties u j for earliness of a job j, where u j is a random real number in the range [0, w j ]. This
set consists of 432 small instances and 576 large instances, hence, totalizing 1008 instances. They
are subdivided by the number of jobs (n), machines (m), and stages per machine (mi ). The smaller

C 2019 The Authors.
instances have the following settings: n ∈ {5, 7, 9, 11, 13, 15}, m ∈ {2, 3}, and mi = 3. The larger
instances have n ∈ {50, 100, 150, 200}, m ∈ {4, 8}, and mi ∈ {2, 4}.
5.1. Metrics
This subsection presents the metrics used to evaluate the performance of the proposed algorithm.
The used metrics are the Hypervolume, the Epsilon indicator, and the Spacing indicator. These
metrics are briefly described as follows.
The Hypervolume metric H (Qalg, R0 ), proposed by Zitzler and Thiele (1998), measures the
volume between the Pareto frontier Qalg obtained by the algorithm alg and a reference point R0 .
An area with greater volume indicates both a greater scattering of the solutions and a greater
convergence of the solutions. Thus, the higher the Hypervolume, the better the algorithm. The

C 2019 The Authors.
reference point R0 was defined by instance as the highest value of the objectives contained in the
union set of all the solutions found after all the experiments performed in this work.
The Epsilon indicator Ie (Qalg, Qre fi ) was developed by Zitzler et al. (2003). This indicator de-
termines a minimum factor e which, if multiplied by each point of the set Qre fi , makes the
resultant set of approximations weakly dominated by Qalg. Let Qre fi be the Pareto-optimal
frontier of instance i. Therefore, the lower the value of Ie , the greater the convergence of the
algorithm. The prior knowledge of the Pareto-optimal frontier is necessary for the calculation
of this indicator. However, in many problems presented in the literature, this set is not known;
thus, to evaluate the convergence of the algorithms, a reference set is usually defined and used
as the Pareto-optimal frontier. In the current work, the reference set Qre fi , for each instance i,
contains the nondominated points of the union set of all the experiments performed with the
instance i.

C 2019 The Authors.
The Spacing indicator (Okabe et al., 2003; Yen and He, 2014), proposed by Schott (1995) estimates
the variance of the distances of neighboring solutions belonging to the front Qalg of nondominated
solutions obtained by the algorithm alg. For each solution, the distance between the nearest solution
is found. The value returned by this metric is the standard deviation of the distances found. Values
close to 0 indicate high levels of uniformity between solutions.
5.2. Preliminary tests
Initially, the parameters sizeMax and levelMax of Algorithm 1 and p of Algorithm 6 were calibrated
using the IRACE software (López-Ibáñez et al., 2011, 2016). This package only works with one
cost-per-time value. Therefore, as the proposed algorithm is multiobjective and returns a set of
nondominated solutions, we used the Hypervolume unary metric (Zitzler and Thiele, 1998), which
will be explained in Subsection 5.1, to evaluate the quality of this set. The values used as the basis

C 2019 The Authors.
Fig. 12. Confidence interval for the Epsilon metric: small instances.
for this preliminary test were sizeMax ∈ {50, 100, 150, 200}, levelMax in the integer range between
3 and 9 and p in the integer range between 4 and 8. The value of p > 4 was disregarded for instances
with n < 11.
For these preliminary tests, 25% of the instances were used. These tests did not deal with the total
number of instances to avoid the exhaustive execution of the algorithms, as appointed by Masri
et al. (2019). For testing each configuration, nine instances were chosen at random, totalizing 252
test instances. Each one of the chosen instances has been tested 30 times. From the results of all
the executions per instance, sets of normalized nondominated solutions were generated, which were
evaluated by the Hypervolume metric. Thus, for each of the 252 instances, we have an appropriate
performance measurement value for calibrating via IRACE package.
The IRACE package returned the following parameter settings: sizeMax ∈ {150, 200}, levelMax
= 3 and p = 8. Based on this, sizeMax = 150, levelMax = 3, and p = 8 were defined. However, for
instances with n < 11, the value of p was set to 4.
5.3. Final tests
In this battery of final tests, five algorithms were evaluated. The first algorithm is the proposed
adapted MO-GVNS, shown in Algorithm 1. The second algorithm is the MO-GVNS algorithm

C 2019 The Authors.
Fig. 13. Confidence interval for the Epsilon metric: large instances.
proposed by Duarte et al. (2015). The third algorithm is the MO-RVNS algorithm, which differs
from the adapted MO-GVNS by the fact that the MO-RVNS does not have local search, that is, the
adapted MO-VND method (Line 9 of Algorithm 1) is not executed. The other two are algorithms
from the literature that have been adapted to solve the MOHFS problem under consideration. These
algorithms are NSGA-II, proposed by Deb et al. (2002), and NSGA-III, proposed by Deb and Jain
(2014) and Jain and Deb (2014). NSGA-III is the new version of NSGA-II, and has emerged as
an improvement for the treatment of problems with more than two objectives. The innovation
introduced was the use of reference points in the objective space to calculate the crowding distance
during the selection process of individuals. These two algorithms start with the creation of an
initial population (set of solutions). The initial solution generation method is the same construction
algorithm used in adapted MO-GVNS. Then, the algorithms enter a loop, and each iteration is called
a generation. In each generation, the current population goes through the processes of crossover,
mutation, and selection. In the selection process, the surviving members are chosen for the next
generation. This choice is based on the classification of dominance and the crowding distance.

C 2019 The Authors.
Fig. 14. Confidence interval for the Epsilon metric: large instances (n = 100).
While in NSGA-II this distance is calculated based on all points in the population, in NSGA-III it
is calculated in relation to the reference points that are input data from the method. The versions
of NSGA-II and NSGA-III used here were the ones proposed by Mousavi et al. (2018) and Yuan
et al. (2015), respectively.
The parameters of these algorithms were also calibrated by the IRACE package, as presented
in Subsection 5.2, that is, the same procedure used for calibrating the parameters of adapted
MO-GVNS was used for calibrating the parameters of the MO-GVNS algorithm from Duarte
et al. (2015), NSGA-II, and NSGA-III. The calibrated parameters from IRACE for these three
algorithms are shown in Table 4. The notations adopted in this table are MP Level, maximum
perturbation level; P, population size; pc , crossover probability; pm , mutation probability; and Nr ,
the number of references points. In Table 4 and throughout the remainder of this paper, by simplicity,
the proposed adapted MO-GVNS algorithm is denoted as MO-GVNS1; the original MO-GVNS
algorithm from Duarte et al. (2015) is denoted as MO-GVNS2.

C 2019 The Authors.
To compare the five algorithms considered, the same stopping criterion was established for all of
them. The adopted stopping criterion was the execution time given by 25 × n × m × mi milliseconds.
All 1008 instances were considered in the final tests. Each algorithm was executed 30 times for each
instance, generating, for each of these combinations, a set of normalized nondominated solutions.
The results were compiled for each instance configuration, and then the values of the Hypervolume,
Epsilon, and Spacing metrics presented were calculated through the evolutionary multiobjective
optimization algorithms package (Mersmann, 2012) available in the statistical computation software
R. These results are presented and analyzed in Subsections 5.4 and 5.5.
For calculating these metrics, the values of the objective function f j , obtained for the instance i
and the solution xk and contained in the set of nondominated solutions, were normalized according
to
f ji (xk ) − mini j
normi, j = , (1)
maxi j − mini j

C 2019 The Authors.
where mini j and maxi j are the lowest and highest values found for the objective j in the instance
i, respectively, in all experiments performed in this paper. The final result for each metric is the
average of all runs of each instance. These averages were grouped according to the characteris-
tics of the instances. Therefore, there are 36 average values for each version of the algorithm in
each group.
5.4. Final results
Tables 5–7 show the average values for each of the algorithms in the three metrics considered for
small instances. Tables 8–10 show the average values for each of the algorithms in the three metrics
considered for large instances. In these tables, the first column identifies the algorithm; next columns
bring the average values of the metric considered in the respective table to different job numbers of
instances of the problem.

C 2019 The Authors.
Fig. 17. Confidence Interval for the Spacing metric: small instances.
5.5. Statistical analysis
The Levene test (Levene, 1960) was applied for analyzing the data related to the obtained results,
after performing the algorithm MO-GVNS1 on the test instances. This test evaluates the equality
of variance between data from different samples. If the value of p-value generated by the statistic is
greater than the significance level of 5%, the variance equality hypothesis is not rejected.
The test showed statistical differences of adapted MO-GVNS over all other algorithms in the
Hypervolume and Epsilon metrics, for all instance classes. However, no statistically significant
differences were found between the algorithms for the Spacing metric. As this indicator estimates,
the variance of the distances of nondominated solutions and the values obtained were very close to
0, it means that the resulting solutions of the algorithms are well spread.
Figure 7(a)–(f) shows the confidence interval graphs for the average values of the Hypervolume
metric for each class of small instances. Figures 8(a)–11(d), in turn, bring the graphs to the large
instances for the average values of the same metric. In these graphs, the horizontal axis identifies
each algorithm approached, and the vertical axis represents the average value of the metric for
this algorithm.
Likewise, Fig. 12(a)–(f) shows the confidence interval plot for the average values of the Epsilon
metric for small instances. Furthermore, Figs. 13(a)–16(d) bring the graphs to large instances
concerning the average values of the same metric.

C 2019 The Authors.
Fig. 18. Confidence Interval for the Spacing metric: large instances (n = 50).
Additionally, Fig. 17(a)–(f) shows the confidence interval plot for the average values concerning
the Spacing metric for the small instances. Figures 18(a)–21(d) bring the confidence interval plot
for the average values of the same metric considering large instances. The confidence level of the
ranges shown in all these graphs is 95%.
5.6. Discussion
Evaluating the average results of the approached methods (Subsection 5.1) and the performed
statistical analyzes (Subsection 5.5), the adapted MO-GVNS algorithm surpasses all other methods
approached in this experiment (MO-GVNS algorithm from Duarte et al., 2015; MO-RVNS, NSGA-
II, and NSGA-III) in relation to Hypervolume and Epsilon metrics. In relation to the Spacing metric,
which measures the scattering of the nondominated solutions, there are no significant differences
between the algorithms, which indicates that the algorithms considered are competitive according

C 2019 The Authors.
Fig. 19. Confidence interval for the Spacing metric: large instances (n = 100).
to this metric. It can also be noted from these results that the NSGA-III algorithm obtained better
performance in the smaller instances, whereas in the larger instances the MO-RVNS method was
better. The NSGA-II algorithm is surpassed by the others algorithms in all instances classes. The
superiority of NSGA-III over NSGA-II was already expected since the former is an evolution of
the latter and brings mechanisms to improve optimization with three or more objectives.
The Pareto frontiers in two normalized dimensions obtained by these algorithms are shown in
Fig. 22(a)–(c). In this analysis, the NSGA-II algorithm was excluded, since it has already been
verified that this method is overcome by the other algorithms. In each of the figures, one of the three
objectives was fixed and the other two were considered.
In Fig. 22(a), the weighted sum of the earliness is fixed; the makespan is on the horizontal axis
and the weighted sum of the tardiness is on the vertical axis. In Fig. 22(b), the weighted sum of the
tardiness is fixed; the makespan is on the horizontal axis and the weighted sum of the earliness is
on the vertical axis. On the other hand, in Fig. 22(c), the makespan is fixed; the weighted sum of
the tardiness is on the horizontal axis and the weighted sum of the earliness is on the vertical axis.

C 2019 The Authors.
These figures represent the Pareto frontiers for the normalized results of an instance of 50 jobs,
4 stages, and 2 jobs at each stage. Similar behavior was observed in all large instances. It is worth
noting that not all points of the three-dimensional border are present in any of these graphs. One
can note, once again, the superiority of the adapted MO-GVNS algorithm over the others.
6. Conclusions and future works
This paper addressed the MOHFS scheduling problem. The following three objectives were simul-
taneously approached: the minimization of the makespan, the minimization of the weighted sum of
the earliness, and the minimization of the weighted sum of the tardiness.
The main motivation of this work was to tackle a common problem in the real world with
three conflicting objectives. Minimizing one objective can undermine the optimization of others. In

C 2019 The Authors.
this case, there is no single solution that optimizes all objectives at the same time. A VNS-based
multiobjective algorithm, so-called adapted MO-GVNS, was developed for solving it.
In the proposed algorithm, initially a set of solutions is generated by the construction phase
of the GRASP method and the exploration of the solution space is done through perturbations
performed in solutions belonging to this set. The algorithm applies two local search procedures.
The first local search procedure is the adapted multiobjective variable neighborhood descent multi-
objective variable neighborhood descent method using the exchange, swap, and inversion moves.
The second local search procedure is based on the work of Arroyo et al. (2011). A version of this
algorithm without local search, called MO-RVNS, was also analyzed.
Three metrics were used to compare the adapted MO-GVNS algorithm and the MO-RVNS
algorithm to three other algorithms of the literature, that is, the original MO-GVNS from Duarte
et al. (2015), NSGA-II, and NSGA-III. These metrics are Hypervolume, Epsilon, and Spacing.
The results show a superiority of the adapted MO-VNS algorithm when compared to the other

C 2019 The Authors.
Fig. 22. Pareto fronts for the normalized results of an instance of 50 jobs, 4 stages, and 2 jobs at each stage. In each of
the figures, one of the three objectives was fixed and the other two were considered.
algorithms, since in two of the three metrics used for evaluation (Hypervolume and Epsilon), its
performance was statistically superior, and, in the third metric used for evaluation (Spacing), there
was no statistical difference between its performance and that obtained by the other algorithms.
Future work will give continuity to the development of MO-GVNS for many objectives, as well
as an analysis of the behavior of this method in this case.
Acknowledgments
The authors would like to thank the Brazilian agencies Coordination for the Improvement of
Higher Education Personnel (CAPES), the National Council of Technological and Scientific De-
velopment (CNPq), and the Minas Gerais State Research Foundation (FAPEMIG), as well as the

C 2019 The Authors.
Federal University of Ouro Preto (UFOP), the Federal Center of Technological Education of Minas
Gerais (CEFET-MG), and the Federal Institute of Education, Science and Technology of Triângulo
Mineiro (IFTM) for supporting this research. This study was financed in part by the Coordination
for the Improvement of Higher Education Personnel (CAPES) – Brazil – Finance Code 001. The
authors would like also to thank the valuable comments of the anonymous referees who contributed
to improve this work.
References
Arroyo, J.E.C., dos Santos Ottoni, R., de Paiva Oliveira, A., 2011. Multi-objective variable neighborhood search algo-
rithms for a single machine scheduling problem with distinct due windows. Electronic Notes in Theoretical Computer
Science 281, 5–19.
Asefi, H., Jolai, F., Rabiee, M., Araghi, M.E.T., 2014. A hybrid NSGA-II and VNS for solving a bi-objective no-wait
flexible flowshop scheduling problem. The International Journal of Advanced Manufacturing Technology 75, 5, 1017–
1033.
Behnamian, J., Ghomi, S.M.T.F., Zandieh, M., 2009. A multi-phase covering Pareto-optimal front method to multi-
objective scheduling in a realistic hybrid flowshop using a hybrid metaheuristic. Expert Systems with Applications
36, 8, 11057–11069.
Campos, S.C., Arroyo, J.E.C., 2014. NSGA-II with iterated greedy for a bi-objective three-stage assembly flowshop
scheduling problem. Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation
(GECCO’14), ACM, Vancouver, BC, Canada, pp. 429–436.
Chamnanlor, C., Sethanan, K., Gen, M., Chien, C.F., 2017. Embedding ant system in genetic algorithm for re-entrant
hybrid flow shop scheduling problems with time window constraints. Journal of Intelligent Manufacturing 28, 8,
1915–1931.
Ciavotta, M., Minella, G., Ruiz, R., 2013. Multi-objective sequence dependent setup times permutation flowshop: a new
algorithm and a comprehensive study. European Journal of Operational Research 227, 2, 301–313.
de Siqueira, E.C., Diana, R.O.M., Souza, M.J.F., de Souza, S.R., 2016. A study concerning the application of genetic
algorithms for solving the multi-objective hybrid flowshop scheduling problem. Anais do XIII Encontro Nacional
de Inteligência Artificial e Computacional (ENIA 2016), Recife, Brazil, pp. 301–312.
de Siqueira, E.C., Souza, M.J.F., de Souza, S.R., 2018. A multi-objective variable neighborhood search algorithm for
solving the hybrid flow shop problem. Electronic Notes in Discrete Mathematics 66, 87–94.
de Siqueira, E.C., Souza, M.J.F., de Souza, S.R., de França Filho, M.F., Marcelino, C.G., 2013. An algorithm
based on evolution strategies for makespan minimization in hybrid flexible flowshop scheduling problems. Pro-
ceedings of the 2013 IEEE Congress on Evolutionary Computation (CEC 2013), Cancún, Mexico, pp. 989–
996.
Deb, K., Jain, H., 2014. An evolutionary many-objective optimization algorithm using reference-point-based nondomi-
nated sorting approach, part I: solving problems with box constraints. IEEE Transactions on Evolutionary Computa-
tion 18, 4, 577–601.
Deb, K., Pratap, A., Agarwal, S., Meyarivan, T., 2002. A fast elitist multiobjective genetic algorithm: NSGA-II. IEEE
Transactions on Evolutionary Computation 6, 182–197.
Defersha, F.M., Chen, M., 2012. Mathematical model and parallel genetic algorithm for hybrid flexible flowshop lot
streaming problem. The International Journal of Advanced Manufacturing Technology 62, 1, 249–265.
Deng, J., Wang, L., 2017. A competitive memetic algorithm for multi-objective distributed permutation flow shop
scheduling problem. Swarm and Evolutionary Computation 32, 121–131.
Dios, M., Fernandez-Viagas, V., Framinan, J.M., 2018. Efficient heuristics for the hybrid flow shop scheduling problem
with missing operations. Computers & Industrial Engineering 115, 88–99.
Dorigo, M., Stützle, T., 2004. Ant Colony Optimization. MIT Press, Cambridge, MA.
Duarte, A., Pantrigo, J.J., Pardo, E.G., Mladenovic, N., 2015. Multi-objective variable neighborhood search: an applica-
tion to combinatorial optimization problems. Journal of Global Optimization 63, 3, 515–536.

C 2019 The Authors.
Dubois-Lacoste, J., López-Ibáñez, M., Stützle, T., 2009. Effective hybrid stochastic local search algorithms for biobjective
permutation flowshop scheduling. In Blesa, M.J., Blum, C., Di Gaspero, L., Roli, A., Sampels, M., Schaerf, A. (eds)
Hybrid Metaheuristics. Springer, Berlin, pp. 100–114.
Dugardin, F., Yalaoui, F., Amadeo, L., 2010. New multi-objective method to solve reentrant hybrid flow shop scheduling
problem. European Journal of Operational Research 203, 1, 22–31.
Ehrgott, M., 2005. Multicriteria Optimization (2nd edn). Springer, Berlin.
Feo, T.A., Resende, M.G., 1995. Greedy randomized adaptive search procedures. Journal of Global Optimization 6, 2,
109–133.
Geiger, M.J., 2004. Randomised variable neighbourhood search for multi-objective optimisation. Proceedings of EU/ME
Workshop: Design and Evaluation of Advanced Hybrid Meta-heuristics, Nottingham, pp. 34–42.
Gomes, H.C., das Neves, F.d.A., Souza, M.J.F., 2014. Multi-objective metaheuristic algorithms for the resource-
constrained project scheduling problem with precedence relations. Computers & Operations Research 44, 92–104.
Gong, D., Han, Y., Sun, J., 2018. A novel hybrid multi-objective artificial bee colony algorithm for blocking lot-streaming
flow shop scheduling problems. Knowledge-Based Systems 148, 115–130.
Hansen, P., Mladenović, N., Pérez, J.A.M., 2008. Variable neighborhood search: methods and applications. 4OR—A
Quarterly Journal of Operations Research 6, 4, 319–360.
Holland, J.H., 1975. Adaptation in Natural and Artificial Systems. An Introductory Analysis with Application to Biology,
Control, and Artificial Intelligence. University of Michigan Press, Ann Arbor, MI.
Ishibuchi, H., Tsukamoto, N., Nojima, Y., 2008. Evolutionary many-objective optimization: a short review. Proceedings
of the 2008 IEEE Congress on Evolutionary Computation, Hong Kong, China, pp. 2419–2426.
Jain, H., Deb, K., 2014. An evolutionary many-objective optimization algorithm using reference-point based nondomi-
nated sorting approach, part II: handling constraints and extending to an adaptive approach. IEEE Transactions on
Evolutionary Computation 18, 4, 602–622.
Kostreva, M.M., Ogryczak, W., 1999. Linear optimization with multiple equitable criteria. RAIRO —Operations Research
33, 3, 275–297.
Kostreva, M.M., Ogryczak, W., Wierzbicki, A., 2004. Equitable aggregations and multiple criteria analysis. European
Journal of Operational Research 158, 2, 362–377.
Lei, D., Zheng, Y., 2017. Hybrid flow shop scheduling with assembly operations and key objectives: a novel neighborhood
search. Applied Soft Computing 61, 122–128.
Levene, H., 1960. Robust tests for equality of variances. In Olkin, I., Ghurye, S.G., Hoeffding, W., Madow, W.G., Mann,
H.B. (eds) Contributions to Probability and Statistics: Essays in Honor of Harold Hotelling. Stanford University Press,
Palo Alto, CA, pp. 278–292.
Li, J.Q., Han, Y.Y., Wang, C.G., 2017. A hybrid artificial bee colony algorithm to solve multi-objective hybrid flowshop in
cloud computing systems. In Sun, X., Chao, H.C., You, X., Bertino, E. (eds) Proceedings of the Third International
Conference on Cloud Computing and Security (ICCCS 2017), Springer International, Nanjing, pp. 201–213.
Li, J.Q., Pan, Q.K., Gao, K.Z., 2011. Pareto-based discrete artificial bee colony algorithm for multi-objective flexi-
ble job shop scheduling problems. The International Journal of Advanced Manufacturing Technology 55, 9, 1159–
1169.
Li, J.Q., Sang, H.Y., Han, Y.Y., Wang, C.G., Gao, K.Z., 2018. Efficient multi-objective optimization algorithm for hybrid
flow shop scheduling problems with setup energy consumptions. Journal of Cleaner Production 181, 584–598.
Li, X., Li, M., 2015. Multiobjective local search algorithm-based decomposition for multiobjective permutation flow
shop scheduling problem. IEEE Transactions on Engineering Management 62, 4, 544–557.
Li, X., Ma, S., 2016. Multi-objective memetic search algorithm for multi-objective permutation flow shop scheduling
problem. IEEE Access 4, 2154–2165.
Liang, Y.C., Chen, A.H.L., Tien, C.Y., 2009. Variable neighborhood search for multi-objective parallel machine scheduling
problems. Proceedings of the 8th International Conference on Information and Management Sciences (IMS 2009),
Kunming, pp. 519–522.
Liang, Y.C., Chuang, C.Y., 2013. Variable neighborhood search for multi-objective resource allocation problems. Robotics
and Computer-Integrated Manufacturing 29, 3, 73–78.
Liang, Y.C., Lo, M.H., 2010. Multi-objective redundancy allocation optimization using a variable neighborhood search
algorithm. Journal of Heuristics 16, 3, 511–535.

C 2019 The Authors.
López-Ibáñez, M., Dubois-Lacoste, J., Pérez Cáceres, L., Stützle, T., Birattari, M., 2016. The IRACE package: iterated
racing for automatic algorithm configuration. Operations Research Perspectives 3, 43–58.
López-Ibáñez, M., Dubois-Lacoste, J., Stützle, T., Birattari, M., 2011. The IRACE package: iterated race for automatic
algorithm configuration. Technical Report TR/IRIDIA/2011-004, IRIDIA, Université Libre de Bruxelles, Belgium.
Available at http://iridia.ulb.ac.be/IridiaTrSeries/IridiaTr2011-004.pdf (accessed October 31, 2018).
López-Sánchez, A., Hernández-Dı́az, A., Gortázar, F., Hinojosa, M., 2018. A multiobjective GRASP–VND algorithm
to solve the waste collection problem. International Transactions in Operational Research 25, 2, 545–567.
Lourenço, H.R., Martin, O.C., Stützle, T., 2003. Iterated local search. In Glover, F., Kochenberger, G. (eds) Handbook of
Metaheuristics. International Series in Operations Research and Management Science. Kluwer Academic Publishers,
Boston, MA, pp. 321–353.
Lu, C., Gao, L., Li, X., Pan, Q., Wang, Q., 2017. Energy-efficient permutation flow shop scheduling problem using a
hybrid multi-objective backtracking search algorithm. Journal of Cleaner Production 144, 228–238.
Marichelvam, M.K., Geetha, M., 2014. Solving tri-objective multistage hybrid flow shop scheduling problems using a
discrete firefly algorithm. International Journal of Intelligent Engineering Informatics 2, 4, 284–303.
Masri, H., Krichen, S., Guitouni, A., 2019. Metaheuristics for solving the biobjective single-path multicommodity
communication flow problem. International Transactions in Operational Research 26, 2, 589–614.
Mersmann, O., 2012. EMOA: evolutionary multiobjective optimization algorithms. Available at https://CRAN.R-
project.org/package=emoa. Version 0.5-0 (accessed October 31, 2018).
Minella, G., Ruiz, R., Ciavotta, M., 2008. A review and evaluation of multiobjective algorithms for the flowshop scheduling
problem. INFORMS Journal on Computing 20, 3, 451–471.
Minella, G., Ruiz, R., Ciavotta, M., 2011. Restarted iterated Pareto greedy algorithm for multi-objective flowshop
scheduling problems. Computers & Operations Research 38, 11, 1521–1533.
Mladenović, N., Hansen, P., 1997. Variable neighborhood search. Computers & Operations Research 24, 11, 1097–1100.
Mousavi, S.M., Mahdavi, I., Rezaeian, J., Zandieh, M., 2018. An efficient bi-objective algorithm to solve re-entrant hybrid
flow shop scheduling with learning effect and setup times. Operational Research 18, 1, 123–158.
Naderi, B., Ruiz, R., Zandieh, M., 2010. Algorithms for a realistic variant of flowshop scheduling. Computers & Operations
Research 37, 236–246.
Okabe, T., Jin, Y., Sendhoff, B., 2003. A critical survey of performance indices for multi-objective optimisation. Proceedings
of the 2003 Congress on Evolutionary Computation (CEC ’03), Vol. 2, Canberra, pp. 878–885.
Paquete, L., Chiarandini, M., Stützle, T., 2004. Pareto local optimum sets in the biobjective traveling salesman problem:
an experimental study. In Gandibleux, X., Sevaux, M., Sörensen, K., T’kindt, V. (eds) Metaheuristics for Multi-
objective Optimisation, Lecture Notes in Economics and Mathematical System, Vol. 535. Springer, Berlin, pp. 177–
199.
Pargar, F., Zandieh, M., Kauppila, O., Kujala, J., 2018. The effect of worker learning on scheduling jobs in a hybrid flow
shop: a bi-objective approach. Journal of Systems Science and Systems Engineering 27, 3, 265–291.
Rego, M.F., Souza, M.J.F., Coelho, I.M., Arroyo, J.E.C., 2014. Multi-objective algorithms for the single machine schedul-
ing problem with sequence-dependent family setups. In Snášel, V., Krömer, P., Köppen, M., Schaefer, G. (eds) Soft
Computing in Industrial Applications, Advances in Intelligent Systems and Computing, Vol. 223. Springer, Berlin, pp.
117–127.
Ruiz, R., Sivrikaya, F., Urlings, T., 2008. Modeling realistic hybrid flexible flowshop scheduling problems. Computers &
Operations Research 35, 1151–1175.
Ruiz, R., Stützle, T., 2007. A simple and effective iterated greedy algorithm for the permutation flowshop scheduling
problem. European Journal of Operational Research 177, 2033–2049.
Schilde, M., Doerner, K.F., Hartl, R.F., Kiechle, G., 2009. Metaheuristics for the bi-objective orienteering problem.
Swarm Intelligence 3, 3, 179–201.
Schott, J.R., 1995. Fault tolerant design using single and multicriteria genetic algorithm optimization. MS thesis, Depart-
ment of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA.
Srinivas, N., Deb, K., 1995. Multi-objective function optimization using non-dominated sorting genetic algorithms.
Torkashvand, M., Naderi, B., Hosseini, S., 2017. Modelling and scheduling multi-objective flow shop problems with
interfering jobs. Applied Soft Computing 54, 221–228.

C 2019 The Authors.
Urlings, T., 2010. Heuristics and metaheuristics for heavily constrained hybrid flowshop problems. PhD thesis, Univer-
sidad Politécnica de Valencia. Available at https://riunet.upv.es/bitstream/handle/10251/8439/tesisUPV3302.pdf
(accessed October 31, 2018).
Urlings, T., 2011. Heuristics and Metaheuristics for Heavily Constrained Hybrid Flowshop Problems. Dissertations in
Artificial Intelligence, Vol. 331. IOS Press, Amsterdam.
Urlings, T., Ruiz, R., 2010. Genetic algorithms with different representation schemes for complex hybrid flexible flow line
problems. International Journal of Metaheuristics 1, 30–54.
Wang, H., Fu, Y., Huang, M., Huang, G.Q., Wang, J., 2017. A NSGA-II based memetic algorithm for multiobjective
parallel flowshop scheduling problem. Computers & Industrial Engineering 113, 185–194.
Wang, S., Liu, M., 2014. Two-stage hybrid flow shop scheduling with preventive maintenance using multi-objective tabu
search method. International Journal of Production Research 52, 5, 1495–1508.
Wang, X., Tang, L., 2017. A machine-learning based memetic algorithm for the multi-objective permutation flowshop
scheduling problem. Computers & Operations Research 79, 60–77.
Xu, J., Wu, C.C., Yin, Y., Lin, W.C., 2017. An iterated local search for the multi-objective permutation flowshop scheduling
problem with sequence-dependent setup times. Applied Soft Computing 52, 39–47.
Xu, L., Yeming, J., Ming, H., 2016. Solving hybrid flow-shop scheduling based on improved multi-objective artificial bee
colony algorithm. Proceedings of the 2nd International Conference on Cloud Computing and Internet of Things
(CCIOT 2016), IEEE, Dalian, pp. 43–47.
Yang, X.S., 2010. Nature-Inspired Metaheuristic Algorithms (2nd edn). Luniver Press, Bristol.
Yen, G.G., He, Z., 2014. Performance metric ensemble for multiobjective evolutionary algorithms. IEEE Transactions on
Ying, K.C., Lin, S.W., Wan, S.Y., 2014. Bi-objective reentrant hybrid flowshop scheduling: an iterated Pareto greedy
algorithm. International Journal of Production Research 52, 19, 5735–5747.
Yuan, X., Tian, H., Yuan, Y., Huang, Y., Ikram, R.M., 2015. An extended NSGA-III for solution multi-objective
hydro-thermal-wind scheduling considering wind power cost. Energy Conversion and Management 96, 568–578.
Yuan, Y., Xu, H., Wang, B., 2014. An improved NSGA-III procedure for evolutionary many-objective optimization.
Proceedings of the 2014 Annual Conference on Genetic and Evolutionary Computation (GECCO 2014), ACM, pp.
661–668.
Zandieh, M., Mozaffari, E., Gholami, M., 2010. A robust genetic algorithm for scheduling realistic hybrid flexible flow
line problems. Journal of Intelligent Manufacturing 21, 731–743.
Zitzler, E., Laumanns, M., Thiele, L., 2002. SPEA2: improving the strength Pareto evolutionary algorithm for multiobjec-
tive optimization. In Giannakoglou, K.C. et al. (eds) Evolutionary Methods for Design, Optimisation and Control with
Application to Industrial Problems (EUROGEN 2001). International Center for Numerical Methods in Engineering
(CIMNE), Barcelona, pp. 95–100.
Zitzler, E., Thiele, L., 1998. An evolutionary approach for multiobjective optimization: the strength Pareto approach.
TIK Report 43, Computer Engineering and Networks Laboratory (TIK), ETH Zurich, Zurich.
Zitzler, E., Thiele, L., Laumanns, M., Fonseca, C.M., da Fonseca, V.G., 2003. Performance assessment of multiobjective
optimizers: an analysis and review. IEEE Transactions on Evolutionary Computation 7, 2, 117–132.

C 2019 The Authors.

Artigo Heuristica Multi Objetivo

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Artigo Heuristica Multi Objetivo

Caricato da

Copyright:

Formati disponibili

INTERNATIONAL

An MO-GVNS algorithm for solving a multiobjective hybrid

(i) Fj : set of stages visited by job j, 1 < |Fj | < m;

(i) makespan minimization (Cmax );

4. The proposed MO-GVNS algorithm

4.1. The proposed MO-GVNS algorithm

Algorithm 1. Adapted MO-GVNS

Fig. 5. Representation of a solution s.

4.2. Representation of a solution

4.3. Initial solutions

4.4. Job assignment

Algorithm 3. Job assignment

Fig. 6. Types of moves.

4.5. Neighborhood structures

4.6. Adapted MO-VND procedure

Algorithm 4. Adapted MO-VND

4.7. Local search algorithms

4.8. Perturbation procedure

The perturbation procedure, included at Line 8 of Algorithm 1, is shown in Algorithm 7. This

Algorithm n=5 n=7 n=9 n = 11 n = 13 n = 15

Algorithm n=5 n=7 n=9 n = 11 n = 13 n = 15

Algorithm n=5 n=7 n=9 n = 11 n = 13 n = 15

Algorithm n = 50 n = 100 n = 150 n = 200

Algorithm n = 50 n = 100 n = 150 n = 200

Algorithm n = 50 n = 100 n = 150 n = 200

Fig. 7. Confidence interval for the Hypervolume metric: small instances.

5.2. Preliminary tests

5.3. Final tests

5.4. Final results

5.5. Statistical analysis

6. Conclusions and future works

Potrebbero piacerti anche