Computers & Industrial Engineering 145 (2020) 106491

Contents lists available at ScienceDirect

Computers & Industrial Engineering

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

Discrete scenario-based optimization for the robust vehicle routing problem: T

The case of time windows under delay uncertainty
Lei Wua,1, Mhand Hifib,
⁎,2

a
Wenlan School of Business at Zhongnan University of Economics and Law, China
b
EPROAD EA 4669, University of Picardie Jules Verne, France

ARTICLE INFO ABSTRACT

Keywords: In this paper we propose a robust optimization strategy for the vehicle routing problem with time windows, where
Discrete scenario the travel time is considered as uncertain. The objective is to minimize the risk of delay related to the time
Optimization windows constraint. We first present a robust model in which the uncertain travel time is related to a discrete set
Robustness of scenarios: each scenario can be viewed as an observation of time required to complete a current route. Such a
Uncertainty
model is based upon a mixed-integer linear programming that can handle an optimal (solution) value related to
Risk of delay
the worst observation of the total travel time over all available scenarios. Second, in order to evaluate the effects
on the scenario model, a guided neighborhood search-based heuristic is adapted for solving the model and tested on
a variety of instances obtained by using Solomon’s standard generator, where a total of 5040 instances are
considered. Finally, we study the behavior of the adapted algorithm to solve the robust model and highlight the
interaction between the number of scenarios used which are based upon uncertain events and the uncertainty of
the problem.

1. Introduction
During the past decade, e-commerce has made great progress
throughout the world, and the new model of commodity trading has
brought new challenges to logistics. For instance, in cities with sub-
stantial traffic pressure, the uncertainty related to real-time traffic di-
rectly affects the reliability of the distribution planning strategy.
Unfortunately, considerable information, such as the return of risk asset
after one period and the travel time for a specified route, is often un-
known or uncertain for real-world applications. Therefore, decision
making under uncertainty is encountered in numerous domains, such as
transportation, logistics, telecommunication, reliability and production
management. Despite the technological progress in recent years, ad-
dressing some optimization problems with uncertainty parameters re-
mains a challenging topic.
In classical mathematical models, solving an optimization problem
under uncertainty often amounts to interpreting uncertain events as
deterministic parameters (like experience value, variance, skewness,
and kurtosis). In literature, two mainstream approaches can be dis-
tinguished: (i) stochastic optimization and (ii) robust optimization (see,
e.g., Bertsimas & Sim, 2004; Ben-Tal, El Ghaoui, & Nemirovski, 2009;
Adida & Perakis, 2010). In stochastic optimization, uncertain events are
interpreted as random variables that are associated with a certain
probability distribution. Indeed, uncertain data usually contain “ob-
scur” information, where determining the right probability distribution
remains difficult. In contrast to the stochastic optimization, the robust
optimization consists of characterizing uncertain events through the use
of a discrete set of scenarios, where each scenario corresponds to a
particular observation related to the uncertain event. In the area of risk
management, risk aversion is the behavior of the decision maker who
prefers the solution with the lowest risk when faced with uncertainty.
For instance, a risk-averse investor is an investor who attempts to
minimize losses in the worst-case scenario. Other practical problems,
with case study, have been also tackled when considering some un-
certainty data (cf., Alvarez, S.M., Espinoza, & Verab, 2019; Moradi &
Ghezavati, 2019). As an extension of the robust vehicle routing pro-
blem, which is proposed in Bertsimas and Simchi-Levi, 1996), the ro-
bust vehicle routing problem with time windows (RVRPTW) considers
not only on total travel time, but also pays attention to the delivery
time. Therefore, the objective of this paper is to develop a robust

Corresponding author.
⁎

E-mail address: hifi@u-picardie.fr (M. Hifi).

1
He got his first master from University of Paris 1 and second master from Paris Dauphine University. Finally, he got Ph.D in Computer Science and Operations
Research from University of Picardie Jules Verne, France. His research interest is combinatorial optimization for decision aiding.
2
He is the head of the laboratory EPROAD of the UPJV. His research interest is NP Hard combinatorial optimization applied to Logistic and OR problems.

https://doi.org/10.1016/j.cie.2020.106491
Received 12 November 2019; Received in revised form 11 April 2020; Accepted 17 April 2020
Available online 16 May 2020
0360-8352/ © 2020 Elsevier Ltd. All rights reserved.
L. Wu and M. Hifi
optimization model used to provide the most time-saving routing plan
with the minimal risk of delay.
2. Related works
The Vehicle Routing Problem with Time Windows (VRPTW) is a
well-known NP-hard problem belonging to the family of vehicle routing
problems (see, e.g., Toth & Vigo, 2014). The VRPTW aims to determine
a routing plan that satisfies the demands of all customers with a
minimum travel distance. For each costumer, the vehicle must deliver a
fixed quantity of goods within a scheduled time period, and overdue
deliveries are not allowed. In real-world applications, transport effi-
ciency is usually measured by travel time. Due to the uncertainty in the
actual traffic, the travel time of a vehicle between two locations is
difficult to accurately predict. As mentioned previously, both stochastic
and robust optimizations can be applied to decrease the uncertainty
whenever the travel time is assumed to be uncertain in the VRPTW (the
problem is then noted RVRPTW for Robust VRPTW). Several studies in
the literature have proposed solutions for the VRPTW with stochastic
travel times (a rich survey on the stochastic version of the VRPTW can
be found in Gendreau, Jabali, & Rei, 2016; Ritzinger, Puchinger, &
Hartl, 2016; Pérez-Rodríguez & Hernández-Aguirre, 2019). The objec-
tive of the RVRPTW is to determine a reliable routing plan in an un-
certain context while optimizing the travel time that satisfies all cus-
tomer demands. Based on previous research results, the main
contribution of this work is to study the effect of the discrete scenario-
based optimization on reducing the risk of delay.
To the best of our knowledge, most robust models addressing the
RVRPTW are based on adjustable robust optimization (cf. Ben-Tal,
Goryashko, Guslitzer, & Nemirovski, 2004) and the budget uncertainty
polytope (cf. Bertsimas & Sim, 2004). Agra et al. (2013) proposed two
robust formulations for the RVRPTW with the help of an uncertainty
polytope. These two formulations were based on generalizing the
classical resource inequalities and the path inequalities (cf. Kallehauge,
Boland, & Madsen, 2007) in the uncertain context. Agra et al. (2013)
showed that the proposed exact method was able to find an optimal
solution for the RVRPTW only for small-sized instances. In the frame-
work of Agra et al. (2013) and Braaten, Gjønnes, Hvattum, and Tirado
(2017), an adaptive large neighborhood search for solving large-scale
instances of the RVRPTW has been proposed. Hu, Lu, Liu, and Zhang
(2018) generalized the budget uncertainty polytope to describe both
the travel time and the quantity of goods, and developed an adaptive
variable neighborhood search (see, e.g., Stenger, Vigo, Enz, & Schwind,
2013) to solve large-scale instances. Although these approaches showed
high efficiency to reduce delay in delivery, the framework of Agra et al.
(2013) did not take into account the uncertainty of total travel time.
However, for the RVRPTW, the solution with the minimum travel time
is more reliable than the solution with the minimum travel distance.
Indeed, different from the total travel distance, the total travel time is
composed of both the time consumed by the vehicle during transpor-
tation and the time required to wait in case of early arrival. Therefore,
the robust optimization model focuses on providing evaluation of the
time required for vehicles to complete all orders without delay.
The proposed robust model is based upon the discrete scenario
optimization studied in Kouvelis and Yu (1997), Bertsimas and Brown
(2009), and Bertsimas, Brown, and Caramanis (2011). Under the as-
sumptions of robust discrete optimization, the travel time between two
locations is represented by a discrete set of scenarios, where each sce-
nario represents a possible travel time for vehicles traveling from one
location to another. The objective of the robust discrete optimization is
to find a solution that is qualified under a predefined decision maker’s
preference: such a solution is also said to be a robust criterion (see, e.g.,
Aissi, Bazgan, & Vanderpooten, 2009; Roy, 2010; Gabrel, Murat, &
Thièle, 2014). To the best of our knowledge, few research articles dis-
cussed the application of robust discrete optimization directly to solve
the RVRPTW. Among all available robust discrete optimization-based
2
Computers & Industrial Engineering 145 (2020) 106491
models in the literature, we cite some recent representative results re-
lated to the RVRPTW. Han, Lee, and Park (2013) proposed a simplified
robust model for the RVRP. Instead of computing a solution qualified by
a robust criterion, the authors associated the travel cost with a penalty,
where the aforementioned penalty is used to measure the excess
duration on the route according to each scenario. Based on the worst-
case criterion, Solano-Charris, Prins, and Santos (2015) proposed a
metaheuristic combined with a series of efficient local searches for the
RVRP. Wu, Hifi, and Bederina (2017) proposed an improved robust
criterion for the RVRP. Through comparative analyses, the authors
showed that the solution provided by using the new robust criterion
generally performed better than those deduced from the classical robust
criteria.
As shown in Baldacci, Mingozzi, and Roberti (2011), Baldacci,
Mingozzi, and Roberti (2012), Vidal, Crainic, Gendreau, and Prins
(2013), providing an optimal solution for the VRPTW is time-con-
suming, and using an exact method for solving the VRPTW becomes
inappropriate, especially when tackling large-sized instances. To find
high-quality solutions for large-scale instances, a significant number of
metaheuristics have been proposed for the VRPTW (for more details,
the reader may refer to Vidal, Crainic, Gendreau, & Prins (2014)). As an
extension of the VRPTW, the robust discrete optimization-based model
for the VRPTW under travel time uncertainty has a complex structure.
Therefore, in order to evaluate the behavior of the proposed method,
two parts are distinguished. The first part is devoted to the behavior of
the method on small-sized instances, where both optimal and approx-
imate solution values are computed. The second part analysis the be-
havior of the method on large-scale instances, where a neighborhood
search-based metaheuristic is proposed for tackling such a type of in-
stances.
The remainder of the paper is organized as follows. Section 3 dis-
cusses a mixed-integer linear programming for the RVRPTW. Section 4
presents an efficient heuristic used for providing approximate solutions
(near-upper bounds) for the RVRPTW. Section 5 describes the principle
of the proposed guided neighborhood search. Section 6 reports the re-
sults achieved by the proposed method when applied to the proposed
robust model tailored for the RVRPTW.
3. A discrete scenario-based model for the RVRPTW
In this section, we propose a Mixed-Integer linear Programming
(MIP) for the RVRPTW, where the uncertain parameters (i.e., the travel
time) is represented by a set of discrete scenarios. We assume that the
distribution of the uncertainty parameters is not known. Therefore, all
sets of scenarios are uniformly generated. The proposed MIP is based on
the application of the Miller-Tucker-Zemlin sub-tour elimination con-
straints to avoid sub-tours (cf., Miller, Tucker, & Zemlin, 1960; Bektaş &
Gouveia, 2014).
Indeed, an instance of the RVRPTW is composed of a central depot
(denoted by 0), a set of n customers V = {1, …, n} and a set of identical
vehicles of capacity C. Each customer i ( i V ) has a quantity ci of
goods to be delivered and is available only for a fixed period of time,
which can be denoted as a time window [eti, lti]. The service time for a
vehicle to load all the goods of customer i is denoted by sti . For each
pair (i, j) ( i j {0} V ), the travel time between i and j is de-
scribed by a set of NS scenarios tijs ( s = 1, …, NS ), where each scenario
represents a possible time required by a vehicle when traveling between
i and j. In other words, the travel time between each pair of nodes is
characterized by NS independent observations. Due to the uncertainty
in the travel time, the main goal of the RVRPTW is to find a solution
that has a considerable chance of being the routing plan with the
minimum travel time and minimum number of vehicles while mini-
mizing the risk of violating the time window constraints. In the litera-
ture, the worst-case criterion, which minimizes the worst observation
over all considered scenarios, is generally used to find an absolute robust
solution. For the RVRPTW, the application of the worst-case criterion
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

consists of minimizing the worst observation of total travel time. A Algorithm 1. Best-First Strategy for the RVRPTW (BFS)
standard MIP for the RVRPTW, denoted by MIPRVRPTW , can be written as
follows:
Require: An instance of the RVRPTW G.
(MIPRVRPTW ) min r (1) Ensure: A feasible solution LR for G.
1: Let I = {1, …, n} be the set of unvisited customers;
n n n n
2: Set k = 1, Rk = {0} and LR = {Rk } ;
s. c. (t 0si x 0i + tis0 x i0) + tijs x ij + wtis r, 3: while (I ) do
i=1 i=1 j=1 i=i 4: for (each i I do
s = 1, …, NS, (2) 5: Find the best feasible assignment of i in LR, denoted by LRi , such that
TTworst (LRi) is minimized;
n n
6: end for
x 0i = xi0 m, 7: if (cannot find a feasible assignment for i in the current LR) then
i=1 i=1 (3)
8: Set k = k + 1, Rk = {0}, LR = LR {Rk } and go back to Step 4;
n 9: else
x ik = 1, k i , k = 1, …, n , 10: Set LR = LR such that = arg min {TTworst (LRi)} ;
i=0 (4) i
11: end if
n 12: Remove the th customer from I;
xkj = 1, k i , k = 1, …, n, 13: end while
j=0 (5) 14: return LR as a feasible solution for G.

lj li + M (1 xij ) cj, i j = 1, …, n , (6)

For the rest of the paper, we adapt the following notations:
ci li C, i = 1, …n, (7)

tais + sti + tijs + M (x ij tajs , • R : a feasible routing plan associated to the i vehicle; th

• LR: a RVRPTW’s feasible solution (i.e., a list of routes) such that

1) i

s = 1, …, NS, i j = 1, …, n, (8)
LR = {R , R , …} ;
• TT (·): a function that measures the travel time related to R or LR of
1 2

eti tais lti, s = 1, …, NS, i = 1, …, n , (9) s i

the s scenario;
th

ta0s = 0, tais lt 0 sti tis0, • TT (·) : a function displaying the longest (i.e., the worst) travel
worst
s = 1, …, NS, i = 1, …, n, (10) time related to Ri or LR over all scenarios, i.e., TTworst (·) =
max{TT1 (·), …, TTNS (·)} ;
tais (tajs + stj + t jis ) + M (xji 1) wtis,
• NV (·) : a function that measures the number of used vehicles related
s = 1, …, NS , i j = 1, …, n , (11) to LR;

wtis 0, s = 1, …, NS, i = 1, …, n , (12)

• ND (·) : the neighborhood associated to a RVRPTW’s solution.

m , r 0, xij {0, 1}, i j = 0, …, n.
where x ij = 1 if the edge (i, j) is selected, 0 otherwise; wtis denotes the
time required for a vehicle to wait for customer i in the sth scenario; li is
the current load of the vehicle after serving customer i;tais represents
the total travel time in the sth scenario that is required by a vehicle to
arrive at customer i from the center depot. Formula (1) denotes the
objective function, where its goal is to minimize the worst observation
over all considered scenarios. Constraints (2) ensure that for all sce-
narios, the total travel time, including the wait time, required by all
used vehicles does not exceed r. Similarly, constraint (3) ensures that
the number of vehicles that depart from (or return to) the depot does
not exceed m. Constraints (4) and (5) imply that each customer can be
served only one time. Constraints (6) and (7) are used to ensure the
capacity of the vehicle, and the time window constraints are respected
by using Inequalities (8)–(10). Moreover, constraints (6) and (8) are
used to eliminate all sub-tours. Finally, constraints (11) and (12) are
used to compute the amount of time to wait at customer i when a ve-
hicle arrives earlier than eti .
4. A best-first heuristic for the RVRPTW
The complex structure of Constraints (6)–(12) makes MIPRVRPTW
difficult to solve. Furthermore, finding even a feasible solution for
MIPRVRPTW becomes time consuming when the size of instances becomes
large. To efficiently solve the RVRPTW, we propose a Best-First Strategy
(BFS), which consists of sequentially assigning customers to routes,
where only the assignment involving the minimum augmentation of the
objective function is performed. From an economic perspective, the
number of used vehicles is the primary factor in calculating the trans-
port costs. Therefore, BFS first minimizes the number of vehicles, then it
minimizes the total travel time.
Algorithm 1 describes the main steps of the BFS for solving an in-
stance of the RVRPTW (noted G). In the initialization phase (i.e., Steps
1 and 2), a set of unvisited customers I and a list of routes LR are
generated. The outer loop (i.e., Steps 4–6) is used to systematically
assign the unvisited customers to LR. The inner loop (i.e., Steps 4–6) is
responsible for finding the best assignment in LR for each unvisited
customer. In the conditional test (i.e., Steps 7–11), Step 8 ensures that a
new route is generated when the inner loop fails to provide an available
assignment of unvisited customers into the current LR. Step 10 is used
to perform the best assignment over all available assignments de-
termined by Step 5. Step 12 updates the current list of unvisited cus-
tomers, and the outer loop is stopped when all customers have been
assigned to LR. Finally, Step 1 returns a feasible list of routes for the
RVRPTW.
5. A guided neighborhood search for the RVRPTW
A neighborhood search is among the most effective procedures used
to solve large-scale complex optimization problems. A typical neigh-
borhood search consists of two main components: a building procedure
and an exploring procedure. The building procedure generates a
neighborhood, which is a reduced solution space generated from a
feasible solution by resetting a set of fixed variables as “free”. The ex-
ploring procedure focuses on solving the reduced solution space to
provide a new feasible solution. Depending on the modes of building
and exploring the neighborhood, different neighborhood search-based
metaheuristics have been proposed in the literature. Among efficient
approaches, we cite some famous methods related to the RVRPTW, such
as the large neighborhood search (cf. Shaw, 1998), the adaptive large
neighborhood search (cf. Pisinger & Ropke, 2010), the variable neigh-
borhood search (cf. Hansen, Mladenović, Brimberg, & Pérez, 2010), the
hybrid descent method (cf., Bouchakhchoukha & Hifi, 2017), and the

3
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

cooperative parallel neighborhood search (cf. Quan & Wu, 2017), etc. while the value of sizek varies from sizemin to sizemax according to the
Most neighborhood search-based approaches from literature are state of the last K iterations. Indeed, the classical neighborhood
based on exploring a series of randomly generated neighborhoods. Due search consists of determining a local optimum by exploring a series
to the randomness of the search process, a neighborhood search-based of neighborhoods, where the origin of the current neighborhood is
metaheuristic requires alternating building and exploring of a sufficient generally set equal to the solution found in the previous iteration.
number of neighborhoods to provide a competitive solution. In order to However, the randomness of the generation of neighborhoods may
improve the efficiency of the neighborhood search process, we propose result in neighborhood searches failing to find satisfactory solutions.
a Guided Neighborhood Search (namely GNS) for the RVRPTW. A GNS To ensure the quality of neighborhoods to be explored, in the k th
is composed of three steps: (1) to apply a guided building procedure to iteration of GNS, orgk is setting equal to LRk 1 if
control the quality of the neighborhood to be explored; (2) to apply the TTworst (LRk 1) TTworst (LRbest ) × ;orgk is setting equal to LRbest ,
BFS in order to explore the neighborhood built by the guided building otherwise. Furthermore, GNS expands the neighborhood search
procedure; and (3) to apply a set of local search procedures in order to range when the procedure is unable to constantly improve the local
improve the solution at hand. optimal solution. Formally, the value sizek (sizek [sizemin, sizemax ])
is setting equal to sizemin if a new best solution is found; the procedure
5.1. Guided neighborhood search sets sizek = sizek + when failing to improve the current best so-
lution within K iterations, otherwise. Considering that the explora-
Algorithm 2. Guided Neighborhood Search for the RVRPTW (GNS) tion of large neighborhoods requires extensive computational effort,
the maximum value of sizek is setting equal to sizemax .
Phase 2. Once both the origin and the size of the neighborhood
Require: An instance G of the RVRPTW.
have been determined, the second phase applies an iterative pro-
Ensure: A best feasible solution LRbest of G.
1: Apply BFS (see Algorithm 1) to compute a feasible solution of G, namely LR, and
cedure to remove some assigned customers. Given a list of routes LR,
set LRbest = LR ; a random selection of the first customer to be removed from LR is
2: while (stopping criteria are not reached) do made. In the subsequent iterations, the selection of customers to
3: Apply the guided building procedure to yield the neighborhood ND (LR) issuing remove depends on their relation to the previously removed custo-
from LR;
mers. To quantify the relationship between two customers, the fol-
4: Apply the BFS (see Algorithm 1) to solve ND (LR) and renovate LR as the current
solution;
lowing formula is considered (that is similar to that proposed in
5: Apply a set of local search procedures to improve LR; Shaw, 1998). Let i be the index of the customer containing in LR at
6: If NV (LR) is better than NV (LRbest ) , replace LRbest by LR; else if TTworst (LR) is the k th iteration. For each of these customers, the relatedness be-
better than TTworst (LRbest ) , replace LRbest by LR; tween customer i and j ( j V ) can be computed as follows:
7: end while
8: return LRbest the best feasible solution of G. 1
relatednessij = , i LR and j V,
1 + MaxTTij (13)
where MaxTTij = max{tij1, …, tijNS } , which denotes the value of the
Algorithm 2 describes the main steps of GNS. Given an instance, worst scenario between customers i and j. It means that, in the
namely G, of the RVRPTW, Step 1 tries to provide a feasible starting (k + 1)th iteration, customers with higher relatedness are more likely
solution LR for G by calling BFS (see Algorithm 1). The main loop of to be removed from the current solution. Let N r be the total number
GNS (Steps 2–7) stops whenever the runtime limit (denoted by maxtime ) of remaining customers in the list of routes LR. According to
or the maximum number of iterations (denoted by max iter ) is reached. Formula (13), all remaining customers in LR are ranked from
Step 3 applies a guided building procedure to generate a neighborhood highest to lowest relatedness values. Once the ranking is complete,
issuing from the current solution LR (denoted by ND (LR) ). Step 4 re- we remove the ir -th customer in the arranged list from the LR, where
calls BFS to explore the neighborhood ND (LR) to yield a new solution the ir -th customer is determined as follows:
for G and restarts with LR as the new solution. To enhance the per-
formance of GNS, Step 5 calls a series of local search procedures to ir = N r × rn ,
improve the current solution LR. In Step 6, LRbest is updated if a better where rn is a real randomly generated number in [0, 1].
solution arises in the current iteration. Finally, GNS stops with the best
solution LRbest found so far.
5.3. Local search procedures for the RVRPTW
5.2. Guided building procedure for the RVRPTW
Local search is a common technique used to improve local optima.
The main purpose of a local search is to optimize a solution by enu-
The guided building procedure is primarily responsible for con-
merating all its neighbors within a given range. For the family of ve-
trolling the quality of the neighborhood (i.e., the reduced solution
hicle routing problems, a neighbor of a list of routes can be defined as a
space) to be explored. Note that a neighborhood can be generated by
new list that is obtained by performing a number of exchanges in the
removing a set of assigned customers from the corresponding list of
travel itinerary (see, e.g., Groer, Golden, & Wasil, 2010). In order to
routes. In the proposed framework, the current neighborhood is char-
enhance the performance of GNS, after the exploring procedure (i.e.,
acterized by (1) its “origin” and (2) its “size”. Specifically, the “origin”
Step 4 of Algorithm 2), the following four local moves are considered:
reflects a candidate solution used to induce the neighborhood, and the
“size” of the neighborhood corresponds to the number of removed
One-point move: rearranges the order of a delivery;
customers. The proposed guided building procedure is split into two
Two-points move: changes the order in which two customers are
phases as described in what follows.
visited by vehicles;
Two-opt: reassigns two programmed trips between a pair of ad-
Phase 1. The objective of the first phase is to determine a neigh-
jacent customers from the list of routes;
borhood of a fixed size. During the execution of GNS, the origin and
Three-opt: reassigns three programmed trips between a pair of
the size of the neighborhood are dynamically updated. Let orgk be
adjacent customers from the list of routes.
the origin and sizek be the size of the neighborhood generated in the
k th iteration. The selection of orgk is related to the solution achieved
Given a feasible solution LR, during the local search procedure, the
at the (k 1)th iteration LRk 1 and the best solution at hand LRbest ,
local moves are called in order to change the solution LR only if the

4
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 1
Performance of GNS versus the best solutions in literature on Solomon’s instances.
Vidal et al. (2013),
Marinakis et al. (2019) GNS GNS
Best Best over 10 trials Average over 10 trials

Inst. n TDa NVa TDab NVab CPUab TDaa NVaa CPUaa

C1 100 828.38 10.00 828.94 (0.06%) 10.00 (0.00%) 4.75 829.16 10.00 36.76
C2 100 589.86 3.00 589.93 (0.01%) 3.00 (0.00%) 3.98 589.93 3.00 56.54
R1 100 1210.34 11.92 1281.72 (5.57%) 12.75 (6.96%) 258.88 1296.36 12.75 241.69
R2 100 951.03 2.73 1112.65 (14.53%) 3.00 (9.89%) 757.95 1133.17 3.05 887.41
RC1 100 1384.16 11.50 1428.47 (3.10%) 12.50 (8.70%) 319.55 1444.94 12.56 281.49
RC2 100 1119.24 3.25 1347.43 (16.94%) 3.25 (0.00%) 487.96 1392.15 3.35 628.19

corresponding total number of used vehicles NV (LR) or the worst ob-
servation of the total travel time over all scenarios TTworst (LR) is im-
proved. Furthermore, the four considered local moves are performed in
a random way.
6. Experimental part
This section discusses both the effectiveness of the proposed ap-
proximate method and the analysis of the robustness of the proposed
multi-scenarios model. The problem MIPRVRPTW is solved by using the
Cplex solver (version 12.6), the adapted heuristic was coded in C++,
and all considered approaches were tested on the same benchmark
instances and performed on a computer with an Intel Pentium Core i7-
4790 with 3.6 GHz.
RVRPTW and assess the performance of GNS. In the second part, all
tests were conducted on a second set containing 720 large-scale in-
stances, where the number of scenarios NS varies in the discrete in-
terval {100, 500, 1000} , the number of customers n is fixed to 100 and 10
random instances are generated for each type. The objective of the
second part was to assess the performance of GNS when solving large-
sized instances and the interaction between the number of scenarios
and the uncertainty level for each considered instance. For both parts,
the following tunings were used for the parameters used by GNS: was
randomly generated in the continuous interval [0.1, 0.5], was setting
equal to 15, was equal to 1.03, max iter was fixed to 10000, and maxtime
was fixed to 1800 s. Note also because of the random aspect of the
neighborhood search, ten trials of GNS was performed for each tested
instance (for all 5040 instances).

6.2. GNS’ results versus the best results of the literature

6.1. Experimental design
As underlined above, the proposed model is evaluated on a set of
instances obtained by using Solomon’s generator, as proposed in
Solomon (1987). Our study is based upon two influencing parameters:
(i) the analysis of the behavior of the adapted algorithm and its
achieved results on all the instances used and, (ii) the effect of the
discrete scenario optimization model on uncertain events. From
MIPRVRPTW , one can observe that solving an instance of the RVRPTW
depends on the number of customers to be served and the number of
scenarios used to simulate the uncertain events. In our framework, we
assume that an intrinsic connection exists between the number of used
scenarios and the level of uncertainty about the travel time: an event
with high uncertainty must be simulated with a sufficient number of
scenarios. Therefore, the structure of each instance is characterized by
the number of customers, the number of scenarios and the level of
uncertainty.
In what follows, as proposed in Solomon (1987), a group of six
classes of instances is considered: Gr = {C1, C 2, R1, R2, RC1, RC 2} ,
where the instances are referred as Gr_NS_n_l_i with NS (resp. n) the
number of scenarios (resp. customers), l = {25, 50, 75, 100} denotes the
uncertainty level and i is the index of instance. For the notation
C1_10_25_50, a set of 10 instances contained in the class C1, were
considered (as proposed in Solomon, 1987). For each of these instances,
the total number of customers to be served is equal to 25; the travel
time between each pair of customers is observed in 10 scenarios;
and the value of each scenario varies on the interval
[distij, distij + distij × 50%], where “distij ” denotes the Euclidean distance
between customers i and j.
Due to the high complexity of the RVRPTW, the computational re-
sults was divided into two parts. The first part contains all tests con-
ducted on the first set containing 4320 small-sized instances, where the
number of scenarios NS varies in the discrete interval {10, 50, 100} , the
number of customers n varies in the discrete interval {25, 50} and 30
random instances are generated for each type. The objective of the first
part was to determine the computational effort required to solve the
Table 1 reports the results achieved by GNS on Solomon’s instances
containing 100 customers, where the provided results are compared to
those published Vidal et al. (2013), Marinakis, Marinaki, and Migdalas
(2019). First, column 3 tallies the average total distance TDa related to
the best solutions available in literature, and column 4 displays its
average number of vehicles NVa used. Second, columns from 5 to 7
report GNS’ best results over the ten trials: the best solution value TDab ,
its number of vehicles NVab used and the runtime CPUab needed for
matching that solution while columns from 8 to 10 tally GNS’ average
results over ten trials (i.e., TDaa , NVaa and CPUaa , respectively). Third
and last, columns 5 and 6 display the percentage value related to the
gap between GNS’ best solution value and that related to the best so-
lution value of the literature. Formally, the gap is calculated as follow:
x+ xbest
gap = ,
x+
where, xbest denotes the best solution value of the literature (i.e., TDa or
NVa ) and x + is the best solution value achieved by GNS (i.e., either TDab
or NVab ). Now, we comment on the results reported in Table 1. One can
observe that GNS remains competitive, since its provided results are
closest to the best results of the literature, especially for the instances of
type C1, C2, R1 and RC1. We note that a tailored (meta) heuristic for
VRPTW may generally lead results of variable quality, especially when
such a (meta) heuristic uses several special operators for tackling large-
scale instances. Herein, GNS is based upon MIPRVRPTW model, where it
searches for respecting all constraints related to the time windows re-
garding all scenarios inducing a minimum risk of delay. For instances
with 1000 scenarios, the runtime can grow, however the quality of the
solutions achieved becomes significant (as shown from Table 1).
6.3. Behavior of the proposed approach on small-sized instances
The first containing small-sized instances were used in order to
analyze the average runtime required to exactly solve the RVRPTW.
Herein, the Cplex solver (version 12.6) is used for solving MIPRVRPTW ,

5
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 2
Performance of GNS versus the Cplex solver on all small-sized instances.
Cplex GNS GNS versus Cplex

Inst. TTa NVa CPUa NBopt TTa NVa CPUa #> #= #<

C1 4312.28 (3.48%) 4.81 1063.1 391/ 720 4069.73 (1.45%) 4.42 19.1 233 466 21
C2 5278.87 (9.61%) 2.33 913.3 359/ 720 4679.21 (6.54%) 2.0 0.3 243 476 1
R1 2212.21 (1.66%) 13.21 912.9 397/ 720 2210.31 (1.59%) 13.21 8.6 171 548 1
R2 3267.43 (35.02%) 4.99 1801.2 0/ 720 1801.74 (17.6%) 2.5 44.0 491 92 137
RC1 1711.20 (4.27%) 9.16 1086.1 351/ 720 1620.34 (2.26%) 8.54 8.2 298 418 4
RC2 3440.06 (45.02%) 5.36 1801.2 0/ 720 1958.94 (33.19%) 2.5 17.5 439 111 170

where the runtime limit was fixed to 1800 s (considered as a heuristic
whenever the solver fails to prove the optimality). The bounds (related
to the feasible or optimal solutions) provided by the Cplex solver were
compared to those achieved by GNS.
Table 2 reports the results provided by both Cplex and GNS on all
instances of the first set, i.e., instances containing 25 and 50 customers.
In Table 2, column ”Inst.” displays the index of each class, columns from
2 to 5 display the average bounds provided by the Cplex solver for each
of the six classes, where TTa denotes the average value related to the
worst observation for the total travel time, NVa denotes the average
number of vehicles used, CPUa is the average elapsed time for the Cplex
solver, and NBopt represents the number of times that the Cplex solver
matches an optimal solution. Information concerning GNS are dis-
played in columns from 6 to 11: columns from 6 to 8 report the average
quality of the best bounds yielded by GNS overall 10 trials on each
instance, columns from 9 to 11 tally a comparative study between GNS
and Cplex solver, where the column under the notation ”#>” (resp.
”#<”) displays the number of times that GNS (resp. Cplex) dominates
the Cplex solver (resp. GNS) whereas column 10 under the notation
“# =” shows the number of times that both methods matches the same
bounds. Finally, columns 2 and 6 report the percentage values related
to the gap between both the best solution value provided by Cplex and
GNS (noted x +) and the best lower bound reached by Cplex (noted x ).
In this case, the gap is computed as follow:
x+ x
gap = . Because the Cplex solver is unable to provide comparable bounds,
x+
From Table 2, one can observe what follows:
• The Cplex solver has a good behavior on instances of the first four
classes C1, C 2, R1 and RC1 (column 5, lines 1, 2, 3 and 5). In this
case, it is able to provide 391 optimal solutions for C1, 359 for
C2, 397 for R1 and 351 for RC1.
• The Cplex solver fails to prove the optimality of the bounds achieved
for the last two classes R2 and RC2 (column 5, lines 4 and 6).
• According to the gapes reported in both columns 2 and 6, one can
observe that GNS dominates the Cplex solver overall the six classes
tested, especially for instances of both classes R2 and RC2 .
• For both classes R2 and RC2 , GNS is able to achieve significant
improvements for both objectives: a better total travel time for the
worst scenario and a minimum number of used vehicles. Indeed, for
class R2 (resp. RC2 ), the average bounds equal to (1801.74; 2.5)
(resp. (1958.94; 2.5) ) achieved by GNS are better than those provided
by the Cplex solver (i.e., (3267.43; 4.99) for R2 and (3440.06; 5.36) for
RC2 ).
• Furthermore, the average runtime required by GNS (column 8) to
achieve the best bounds is smaller than that required by the Cplex
solver (column 5).
type contains 30 instances). Second, Tables from (8)–(10) show the
detailed results provided by GNS, where for each instance ten trials are
considered: (i) column under ”aa” reports the average results over the
ten instances of each type and for each instance, the average bounds
provided by the ten trials are reported, and (ii) column under ”ab”
displays the average results of the 30 instances of each type, where for
each instance, ten independent trials (runs) are retuned. In what fol-
lows, we comment on the results of Tables from (5)–(10).
• For each class, the average runtime required to solve an instance of
the RVRPTW depends strongly on the number of customers.
• Additionally, the number of scenarios and the uncertainty level also
has a direct impact on the runtime. Indeed, more the number of
scenarios and uncertainty level increase, more the difficulty of sol-
ving the instance increases.
• The Cplex solver fails to achieve optimal solutions for all six classes
whenever the number related to the customers, the scenarios and
the uncertainty level are equal to 50, 100 and 100, respectively.
• GNS is able to maintain the stability of the bounds provided for
small-sized instances. Indeed, the best value (i.e., TTab ) is close to the
average value (i.e., TTaa ) for all six classes, especially for the class
C2.
6.4. Behavior of the proposed approach on large-scale instances
we then decided to run GNS on the second set of instances containing
720 large-scale instances. This part can be viewed as a straightforward
extended study of the first part (Section 6.3) devoted for evaluating the
effectiveness of the GNS when applied for solving the robust model.
Table 3 reports the results provided GNS on the large-scale instances
of RVRPTW. First, column 1 of the table displays the “instance type
label” of the instances related to the six classes while the rest of the
columns (from 2 to 10) report the average total distance, the average
number of vehicles and the average runtime required for achieving the
aforementioned results when varying the number of scenarios for each
class (100, 500 and 1000 scenarios, respectively). In fact, TTab (resp.
NVab ) denotes the average value related to the best total travel time
(resp. the average number of the vehicles used) when considering the
worst-case robust criterion for each type of instance, and CPUab denotes
GNS’s average runtime used for achieving both TTab and NVab .
From Table 3, we can observe that the provided results are close to
the results achieved for the first set of instances, as explained in what
follows.
• The average computational effort generally increases with the
number of scenarios and the uncertainty level (as observed in
Section 6.3 when studying the first set of instances).

The detailed results of all instances related to Table 2 are exposed in the
Appendix (Tables from (5)–(10)). First, Tables from (5)–(7) report the
information related to the average bounds and the number of optimal
solutions reached by the Cplex solver for each type of instances (each
• There exists a high impact on the results related to the number of
scenarios and the uncertainty level on the robustness of the solu-
tions. In fact, the uncertainty level can be used to describe the
magnitude of the change in travel time between two customers.
• By setting the uncertainty level to 100, it implies that the current

6
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 3
Performance of GNS on the second set of instance containing large-scale instances.
NS = 100 NS = 500 NS = 1000

Inst. TTab NVab CPUab TTab NVab CPUab TTab NVab CPUab

C1_NS_100_25 10045.72 10 495.2 10048.41 10 2027.3 10049.11 10 1865.2

C1_NS_100_50 10568.17 11.1 864.0 10610.29 11.5 1898.0 10667.52 11.8 2078.2
C1_NS_100_75 10815.52 12 1505.4 10881.85 12.4 1816.3 10914.10 12.6 1882.3
C1_NS_100_100 10961.94 12.9 1187.5 10986.28 13 2060.4 11006.90 13 2199.0

C2_NS_100_25 9780.33 4 27.1 9782.93 4 284.2 9784.46 4 454.1

C2_NS_100_50 9972.29 4.2 456.3 9982.68 4 1084.0 9984.42 4 792.3
C2_NS_100_75 10068.12 4.1 244.2 10076.67 4 606.5 10079.97 4.1 1107.1
C2_NS_100_100 10170.08 4.1 1140.3 10190.55 4 1549.9 10193.94 4.1 2178.5

R1_NS_100_25 4080.51 24 124.0 4084.79 24 682.4 4085.78 24 548.5

R1_NS_100_50 4357.98 25.3 467.6 4410.16 25.8 1909.9 4424.84 26 1425.6
R1_NS_100_75 4567.33 26 433.9 4588.19 26 1198.2 4592.51 26 1516.2
R1_NS_100_100 4859.73 28 1096.4 4916.13 28.1 2358.1 4955.73 28.5 1789.1

R2_NS_100_25 3054.52 4 2016.5 3067.57 4 1753.7 3073.78 4 1674.3

R2_NS_100_50 3134.31 4 1976.5 3155.66 4 2198.2 3164.97 4 2378.2
R2_NS_100_75 3357.10 4.8 2534.6 3550.20 5 2068.7 3587.25 5 2694.2
R2_NS_100_100 3656.98 5 2126.2 3684.75 5 2783.1 3703.67 5 2352.5

RC1_NS_100_25 3267.24 16.3 1588.0 3321.21 17 1871.9 3324.58 17 2310.2

RC1_NS_100_50 3640.75 19 1422.8 3653.45 19 964.7 3655.73 19 1429.6
RC1_NS_100_75 3856.13 20 1826.0 3934.39 20.4 1851.1 3977.91 20.8 1840.7
RC1_NS_100_100 4166.19 21.9 1061.7 4279.40 22.3 2550.4 4330.78 22.7 2003.7

RC2_NS_100_25 3195.22 4 1556.9 3224.36 4 2522.0 3238.02 4 2688.2

RC2_NS_100_50 3425.07 4.8 1998.1 3506.22 5 2180.4 3516.83 5 2568.0
RC2_NS_100_75 3643.81 5 2134.5 3681.30 5 1738.1 3690.43 5 2082.1
RC2_NS_100_100 3755.02 5 1754.9 3790.66 5 1718.2 3805.17 5 2359.8

travel time is likely to increase to twice the normal level. Using a
large number of observations can reduce the uncertainty about the
travel time, which will lead to more conservative estimations of the
worst total travel time over all considered scenarios (as observed
from the table, both values TTab and NVab increase as the uncertainty
level or the number of scenarios increases).
6.5. Robustness analysis of the risk of delay
Herein, the robustness analysis of the risk of delay related to the
time windows constraint is discussed. In our study, the risk delay
measure is related to the rate of violation. For each instance, 100000
random simulations were performed on the best solution achieved by
GNS. For each simulation, the travel time tij from customer i to j is
randomly generated in the discrete interval [dist ;(dist + dist × l%)]
while the required cumulative travel time tij of each customer j is noted
by taij . Note that if taij exceeds ltj , the time windows constraint related
to the j-th customer is violated. Therefore, the risk of delay is con-
sidered as the average rate induced from 100000 simulations. Formally,
the rate of violation related to the ith iteration can be computed as
follows:
total number of violated constraints
ratei = . strategies, where the best-first strategy is employed for first minimizing
totalnumberofcustomers
Table 4 reports the average violation’s rate of each type of instances
tested. In what follows, we comment on the results reported in Table 4.
• First, one can observe that the average rate of violation varies from
0% to 6% for n = 25, from 0% to 17% for n = 50 , and from 0% to 13%
for n = 100 . It means that the global average rate of violation is less
than 10%.
• Second, the risk associated with the delay seems increasing with
uncertainty level. Indeed, the greater the level of uncertainty, the
higher the risk is, and according to Table 4, the risk related to the
delay also increases with the number of customers.
• Third, the proposed discrete scenario-based optimization model can
be used to reduce the risk of delay. Indeed, for the small-sized in-
stances, through the use of 100 scenarios for characterizing the
uncertainty of travel time. Moreover, its corresponding violation’s
rate is reduced significantly whereas for the large-scale instances,
there is no difference in the term of violation’s rate, especially when
the number of scenarios varies between 500 and 1000.
• Fourth and last, one can observe that in some cases the risk of delay
is more significant (i.e., C1, C 2, R1, RC1) when the discrete sce-
nario-based optimization model is used. In fact, such a phenomenon
is related to the performance of the method used (GNS), which is
able to achieve high-quality solution values.
7. Conclusion
In this paper, we studied the robust vehicle routing problem with
time windows under delay uncertainty. A mixed-integer linear pro-
gramming was proposed in order to establish an optimal solution for
the problem. In order to solve the proposed model, a metaheuristic
based upon the guided neighborhood search was developed for ap-
proximately solving the robust model. The method combines several
the number of vehicles to use and the guided building procedure
combined with a series of local search moves for highlighting the
quality of the solutions at hand. The experimental part showed that the
proposed method was able to yield high-quality solutions for the robust
model. As the proposed model is related to several practical situations,
there are plenty possibilities for further investigation involving efficient
solution procedures. First, because the number of scenarios provides an
interesting information on the risk of delay, It seems to be worth de-
veloping data-driven generation to build scenario set from real datasets.
Second and last, development of efficient local search algorithms can
also be investigated for tackling instances with a large number of sce-
narios, especially for the model used in this work.

7
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 4
Robustness analysis on the violation of time windows.
n = 25 n = 50 n = 100

NS NS NS

Inst. 10 50 100 10 50 100 100 500 1000

C1_NS_n_25 0 0 0 0 0 0 0 0 0
C1_NS_n_50 0.1382% 0.0629% 0.0191% 0.1391% 0.0583% 0.0825% 0.1300% 0.0690% 0.0517%
C1_NS_n_75 0.2955% 0.3633% 0.3252% 0.5749% 0.3516% 0.2178% 0.8827% 1.1580% 1.2144%
C1_NS_n_100 2.2001% 1.8270% 1.5611% 1.3586% 0.5338% 0.5030% 2.5666% 1.5607% 2.8194%

C2_NS_n_25 0.0001% 0 0 0 0 0 0 0 0
C2_NS_n_50 0 0 0 0.1454% 0.0118% 0.0182% 0 0 0
C2_NS_n_75 0.9644% 0.5062% 0.1310% 0.2227% 0.0681% 0.0270% 0 0 0
C2_NS_n_100 0.5506% 0.0002% 0.0001% 0.7312% 0.1744% 0.3029% 0.0110% 0.0094% 0.0130%

R1_NS_n_25 0 0 0 0.1714% 0.1596% 0.1559% 0.3128% 0.2144% 0.2762%

R1_NS_n_50 1.7812% 1.5316% 1.5629% 2.6126% 2.4813% 2.4412% 3.6183% 3.5724% 3.6274%
R1_NS_n_75 2.5506% 2.6298% 2.6620% 6.6244% 6.0223% 5.9934% 8.0110% 7.4610% 7.4098%
R1_NS_n_100 4.0800% 3.7408% 3.5815% 13.1012% 10.5072% 9.9309% 12.7488% 11.3732% 10.9417%

R2_NS_n_25 0 0 0 0.2075% 0.1008% 0.0597% 0.0102% 0.0130% 0.0102%

R2_NS_n_50 0.0004% 0.0003% 0.0002% 1.6892% 0.8824% 0.8434% 0.4864% 0.7428% 0.3062%
R2_NS_n_75 0.7499% 0.1450% 0.1109% 4.3977% 3.1837% 2.1040% 2.6662% 2.8553% 2.4435%
R2_NS_n_100 1.0364% 0.1959% 0.1782% 10.0740% 7.6746% 6.4746% 11.1383% 5.5920% 5.1796%

RC1_NS_n_25 0.0600% 0.0002% 0 0.5604% 0.1921% 0.0838% 0.5429% 0.2212% 0.1483%

RC1_NS_n_50 1.2061% 1.0452% 0.6776% 2.2147% 1.4427% 1.3427% 1.5136% 1.1984% 1.2023%
RC1_NS_n_75 0.600% 0.5575% 0.3472% 7.1123% 5.2730% 4.9945% 6.2487% 5.6768% 5.0085%
RC1_NS_n_100 4.7560% 4.1594% 3.9996% 13.6089% 11.4869% 10.5686% 10.1803% 8.9411% 9.6658%

RC2_NS_n_25 0.0021% 0.0114% 0 0.3298% 0.4386% 0.1723% 0.0100% 0.0204% 0.0247%

RC2_NS_n_50 0.5704% 0.2572% 0.9242% 3.6952% 3.0054% 2.5596% 0.7896% 0.4478% 0.3770%
RC2_NS_n_75 2.3081% 1.1141% 0.6136% 10.2780% 7.6940% 6.9942% 2.7856% 2.4624% 1.6347%
RC2_NS_n_100 5.6257% 2.7259% 2.0168% 16.8474% 12.2946% 12.1416% 7.7543% 5.4414% 5.2155%

Appendix A

Tables 5–10.

Table 5
Behavior of the Cplex solver on instances of the first two classes C1 and C2 .
Inst. TTa NVa GAPa CPUa NBopt Inst. TTa NVa GAPa CPUa NBopt

C1_10_25_25 2793.02 3.0 0.000 79.6 30 C2_10_25_25 3226.26 2.0 0.000 0.8 30
C1_10_50_25 5034.21 5.0 0.000 10.8 30 C2_10_50_25 6065.91 2.0 0.134 1801.2 0
C1_50_25_25 2795.02 3.0 0.000 742.1 30 C2_50_25_25 3228.27 2.0 0.000 15.1 30
C1_50_50_25 5037.32 5.0 0.000 275.4 30 C2_50_50_25 6076.10 2.0 0.144 1801.9 0
C1_100_25_25 2797.85 3.0 0.050 1801.1 0 C2_100_25_25 3228.82 2.0 0.000 69.7 30
C1_100_50_25 5120.82 5.2 0.017 1506.0 19 C2_100_50_25 10164.97 4.4 0.301 1803.7 0
C1_10_25_50 2806.70 3.0 0.000 69.0 30 C2_10_25_50 3247.58 2.0 0.000 0.7 30
C1_10_50_50 5210.47 5.8 0.001 559.2 27 C2_10_50_50 6079.52 2.0 0.126 1801.1 0
C1_50_25_50 2820.20 3.0 0.000 567.1 30 C2_50_25_50 3251.23 2.0 0.000 15.4 30
C1_50_50_50 5453.32 6.2 0.057 1801.8 0 C2_50_50_50 6129.19 2.1 0.142 1802.0 0
C1_100_25_50 2825.70 3.0 0.030 1768.1 4 C2_100_25_50 3252.69 2.0 0.000 61.5 30
C1_100_50_50 7645.81 9.6 0.206 1803.5 0 C2_100_50_50 9584.05 4.1 0.359 1803.9 0
C1_10_25_75 2841.61 3.0 0.000 57.3 30 C2_10_25_75 3269.41 2.0 0.000 0.9 30
C1_10_50_75 5363.63 6.0 0.003 1342.0 19 C2_10_50_75 6094.77 2.0 0.120 1801.0 0
C1_50_25_75 2856.70 3.0 0.000 572.0 30 C2_50_25_75 3281.16 2.0 0.000 15.3 30
C1_50_50_75 5449.67 6.2 0.034 1801.9 0 C2_50_50_75 6117.70 2.0 0.132 1802.0 0
C1_100_25_75 2858.73 3.0 0.030 1793.6 2 C2_100_25_75 3289.77 2.0 0.000 41.8 30
C1_100_50_75 7826.49 9.3 0.198 1802.2 0 C2_100_50_75 8880.53 3.5 0.314 1803.8 0
C1_10_25_100 2876.25 3.1 0.000 72.4 30 C2_10_25_100 3303.54 2.0 0.000 0.9 30
C1_10_50_100 5428.45 6.0 0.004 1062.7 19 C2_10_50_100 6112.04 2.0 0.113 1801.0 0
C1_50_25_100 2911.17 3.3 0.007 787.4 23 C2_50_25_100 3314.58 2.0 0.000 15.1 30
C1_50_50_100 5534.56 6.5 0.035 1801.9 0 C2_50_50_100 6135.40 2.0 0.125 1801.8 0
C1_100_25_100 2971.15 3.7 0.050 1634.5 8 C2_100_25_100 3316.20 2.0 0.000 55.8 29
C1_100_50_100 6235.87 7.5 0.115 1802.2 0 C2_100_50_100 10043.11 4.0 0.294 1803.7 0

8
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 6
Behavior of the Cplex solver on instances of the two classes R1 and R2 .
Inst. TTa NVa GAPa CPUa NBopt Inst. TTa NVa GAPa CPUa NBopt

R1_10_25_25 1587.77 10.0 0.000 17.7 30 R2_10_25_25 1402.81 2.0 0.178 1800.9 0
R1_10_50_25 2266.16 13.0 0.018 1733.5 2 R2_10_50_25 1522.04 2.0 0.325 1800.7 0
R1_50_25_25 1597.13 10.0 0.000 179.4 30 R2_50_25_25 1668.71 2.1 0.409 1801.1 0
R1_50_50_25 2282.57 13.0 0.044 1801.7 0 R2_50_50_25 1962.71 3.0 0.169 1800.8 0
R1_100_25_25 1605.80 10.0 0.000 513.2 30 R2_100_25_25 2158.39 3.1 0.256 1801.4 0
R1_100_50_25 2296.15 13.0 0.056 1803.5 0 R2_100_50_25 10218.86 20.3 0.822 1802.4 0
R1_10_25_50 1768.21 11.2 0.000 9.5 30 R2_10_25_50 1423.79 2.0 0.126 1800.9 0
R1_10_50_50 2514.11 14.6 0.020 1726.2 5 R2_10_50_50 1604.25 2.0 0.303 1800.7 0
R1_50_25_50 1841.61 11.9 0.000 99.0 30 R2_50_25_50 1657.26 2.0 0.359 1801.2 0
R1_50_50_50 2578.87 15.0 0.046 1801.8 0 R2_50_50_50 2193.50 3.0 0.211 1800.7 0
R1_100_25_50 1849.74 12.0 0.000 349.9 30 R2_100_25_50 2450.90 3.4 0.302 1801.4 0
R1_100_50_50 2587.46 15.0 0.055 1803.6 0 R2_100_50_50 9455.80 15.7 0.802 1802.4 0
R1_10_25_75 1864.59 11.8 0.000 6.2 30 R2_10_25_75 1477.59 2.0 0.107 1800.8 0
R1_10_50_75 2662.82 15.2 0.009 1565.3 12 R2_10_50_75 1671.42 2.0 0.285 1800.7 0
R1_50_25_75 1897.98 12.0 0.000 34.3 30 R2_50_25_75 1729.64 2.1 0.342 1801.2 0
R1_50_50_75 2730.01 15.7 0.029 1783.0 1 R2_50_50_75 2298.74 3.0 0.209 1800.7 0
R1_100_25_75 1902.14 12.0 0.000 70.0 30 R2_100_25_75 2666.82 3.7 0.322 1801.4 0
R1_100_50_75 2758.39 15.9 0.044 1803.5 0 R2_100_50_75 10376.40 17.0 0.828 1802.4 0
R1_10_25_100 1915.42 12.0 0.000 3.4 30 R2_10_25_100 1650.12 2.0 0.171 1800.9 0
R1_10_50_100 2789.66 15.9 0.004 1129.8 17 R2_10_50_100 1686.15 2.0 0.239 1800.7 0
R1_50_25_100 1942.92 12.0 0.000 19.6 30 R2_50_25_100 1758.40 2.2 0.302 1801.2 0
R1_50_50_100 2922.37 16.7 0.027 1801.9 0 R2_50_50_100 2411.28 3.0 0.209 1800.9 0
R1_100_25_100 1948.77 12.0 0.000 50.9 30 R2_100_25_100 2838.12 4.0 0.326 1801.4 0
R1_100_50_100 2982.45 17.0 0.047 1803.2 0 R2_100_50_100 10134.51 16.3 0.803 1802.4 0

Table 7
Behavior of the Cplex solver on instances of the last two classes RC1 and RC2 .
Inst. TTa NVa GAPa CPUa NBopt Inst. TTa NVa GAPa CPUa NBopt

RC1_10_25_25 941.13 5.0 0.000 25.5 30 RC2_10_25_25 1574.49 2.0 0.326 1800.8 0
RC1_10_50_25 1794.33 9.1 0.046 1793.5 1 RC2_10_50_25 1576.28 2.0 0.390 1800.7 0
RC1_50_25_25 958.07 5.0 0.000 237.5 30 RC2_50_25_25 1584.28 2.0 0.421 1801.1 0
RC1_50_50_25 1881.64 10.0 0.091 1801.9 0 RC2_50_50_25 2335.64 3.0 0.363 1800.8 0
RC1_100_25_25 959.85 5.0 0.002 1130.3 27 RC2_100_25_25 2873.16 4.0 0.510 1801.5 0
RC1_100_50_25 3910.34 23.9 0.515 1803.4 0 RC2_100_50_25 11673.4 25.0 0.872 1802.5 0
RC1_10_25_50 1010.62 5.0 0.000 15.9 30 RC2_10_25_50 1583.48 2.0 0.291 1800.8 0
RC1_10_50_50 2057.12 11.0 0.042 1801.1 0 RC2_10_50_50 1586.09 2.0 0.358 1800.7 0
RC1_50_25_50 1035.33 5.0 0.000 191.3 30 RC2_50_25_50 1590.33 2.0 0.393 1801.2 0
RC1_50_50_50 2092.23 11.0 0.054 1802.0 0 RC2_50_50_50 2358.09 3.0 0.335 1800.8 0
RC1_100_25_50 1053.01 5.2 0.007 932.8 23 RC2_100_25_50 3012.77 4.3 0.508 1801.4 0
RC1_100_50_50 2128.18 11.1 0.069 1802.9 0 RC2_100_50_50 10670.66 20.0 0.860 1802.5 0
RC1_10_25_75 1105.04 6.0 0.000 34.8 30 RC2_10_25_75 1590.34 2.0 0.273 1800.8 0
RC1_10_50_75 2145.63 11.2 0.026 1801.1 0 RC2_10_50_75 1595.27 2.0 0.342 1800.7 0
RC1_50_25_75 1116.76 6.0 0.000 269.6 30 RC2_50_25_75 1610.75 2.0 0.375 1801.2 0
RC1_50_50_75 2322.21 12.4 0.04 1802.0 0 RC2_50_50_75 2399.83 3.1 0.321 1800.7 0
RC1_100_25_75 1122.01 6.0 0.000 901.5 29 RC2_100_25_75 3043.72 4.2 0.492 1801.4 0
RC1_100_50_75 2397.23 12.8 0.044 1802.2 0 RC2_100_50_75 9947.25 15.5 0.848 1802.5 0
RC1_10_25_100 1130.26 6.0 0.000 14.0 30 RC2_10_25_100 1597.93 2.0 0.253 1800.9 0
RC1_10_50_100 2378.47 12.6 0.021 1777.2 1 RC2_10_50_100 1602.85 2.0 0.319 1800.7 0
RC1_50_25_100 1148.93 6.0 0.000 189.9 30 RC2_50_25_100 1625.10 2.0 0.362 1801.1 0
RC1_50_50_100 2573.43 13.9 0.032 1802.0 0 RC2_50_50_100 2436.78 3.2 0.296 1800.8 0
RC1_100_25_100 1155.67 6.0 0.000 532.2 30 RC2_100_25_100 3052.21 4.3 0.469 1801.4 0
RC1_100_50_100 2651.22 14.6 0.035 1802.2 0 RC2_100_50_100 9640.78 14.9 0.830 1802.5 0

9
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 8
Behavior of GNS on instances of the first two classes C1 and C2 .
Inst. TTab NVab CPUab TTaa NVaa CPUaa Inst. TTab NVab CPUab TTaa NVaa CPUaa

C1_10_25_25 2793.01 3.0 <0.1 2793.01 3.0 0.1 C2_10_25_25 3226.26 2.0 0.1 3226.26 2.0 0.1
C1_10_50_25 5034.21 5.0 3.2 5034.21 5.0 4.2 C2_10_50_25 6065.68 2.0 0.2 6065.68 2.0 0.2
C1_50_25_25 2795.02 3.0 0.2 2795.02 3.0 0.2 C2_50_25_25 3228.27 2.0 0.3 3228.27 2.0 0.2
C1_50_50_25 5037.32 5.0 8.8 5037.32 5.0 8.4 C2_50_50_25 6066.58 2.0 0.4 6066.58 2.0 0.5
C1_100_25_25 2795.24 3.0 0.3 2795.24 3.0 0.2 C2_100_25_25 3228.82 2.0 0.2 3228.82 2.0 0.3
C1_100_50_25 5038.16 5.0 20.8 5038.16 5.0 15.7 C2_100_50_25 6067.22 2.0 1.1 6067.22 2.0 0.9
C1_10_25_50 2806.70 3.0 0.1 2806.7 3.0 0.1 C2_10_25_50 3247.58 2.0 0.1 3247.58 2.0 0.1
C1_10_50_50 5213.13 5.8 16.3 5223.24 5.8 14.5 C2_10_50_50 6079.52 2.0 0.3 6079.52 2.0 0.3
C1_50_25_50 2820.20 3.0 0.2 2820.2 3.0 0.2 C2_50_25_50 3251.23 2.0 0.2 3251.23 2.0 0.2
C1_50_50_50 5327.22 6.0 48.3 5344.23 6.0 46.1 C2_50_50_50 6082.33 2.0 0.7 6082.33 2.0 0.6
C1_100_25_50 2824.82 3.0 0.2 2824.82 3.0 0.2 C2_100_25_50 3252.69 2.0 0.1 3252.69 2.0 0.3
C1_100_50_50 5347.80 6.0 66.0 5356.79 6.0 75.3 C2_100_50_50 6083.05 2.0 0.4 6083.05 2.0 0.7
C1_10_25_75 2841.61 3.0 <0.1 2841.61 3.0 <0.1 C2_10_25_75 3269.41 2.0 0.1 3269.41 2.0 0.1
C1_10_50_75 5371.45 6.0 20.0 5377.86 6.0 17.2 C2_10_50_75 6094.77 2.0 0.2 6094.77 2.0 0.2
C1_50_25_75 2856.70 3.0 <0.1 2856.7 3.0 <0.1 C2_50_25_75 3281.16 2.0 0.1 3281.16 2.0 0.1
C1_50_50_75 5381.66 6.0 32.5 5387.73 6.0 36.0 C2_50_50_75 6098.51 2.0 0.2 6098.51 2.0 0.5
C1_100_25_75 2858.73 3.0 0.2 2858.73 3.0 0.2 C2_100_25_75 3289.77 2.0 <0.1 3289.77 2.0 <0.1
C1_100_50_75 5385.43 6.0 67.0 5391.12 6.0 67.6 C2_100_50_75 6099.80 2.0 0.7 6099.8 2.0 0.7
C1_10_25_100 2876.25 3.1 0.1 2876.25 3.1 0.1 C2_10_25_100 3303.54 2.0 <0.1 3303.54 2.0 <0.1
C1_10_50_100 5426.29 6.0 13.6 5432.3 6.0 14.3 C2_10_50_100 6112.04 2.0 0.2 6112.04 2.0 0.2
C1_50_25_100 2911.17 3.3 0.5 2911.17 3.3 0.5 C2_50_25_100 3314.58 2.0 <0.1 3314.58 2.0 <0.1
C1_50_50_100 5476.27 6.0 55.0 5482.85 6.1 41.1 C2_50_50_100 6119.35 2.0 0.3 6119.35 2.0 0.5
C1_100_25_100 2969.93 3.7 1.2 2969.93 3.7 1.1 C2_100_25_100 3316.20 2.0 <0.1 3316.2 2.0 <0.1
C1_100_50_100 5485.25 6.2 103.8 5491.03 6.2 61.5 C2_100_50_100 6122.76 2.0 0.9 6122.76 2.0 0.8

Table 9
Behavior of GNS on instances of the two classes R1 and R2 .
Inst. TTab NVab CPUab TTaa NVaa CPUaa Inst. TTab NVab CPUab TTaa NVaa CPUaa

R1_10_25_25 1587.77 10.0 <0.1 1587.77 10.0 <0.1 R2_10_25_25 1399.96 2.0 0.1 1399.96 2.0 0.1
R1_10_50_25 2266.29 13.0 9.6 2269.26 13.0 9.6 R2_10_50_25 1802.95 3.0 66.0 1824.21 3.0 49.4
R1_50_25_25 1597.13 10.0 0.1 1597.13 10.0 0.1 R2_50_25_25 1403.02 2.0 0.2 1403.02 2.0 0.2
R1_50_50_25 2275.23 13.0 42.0 2278.01 13.0 27.9 R2_50_50_25 1832.48 3.0 157.6 1878.07 3.0 108.2
R1_100_25_25 1605.8 10.0 0.1 1605.8 10.0 0.1 R2_100_25_25 1403.91 2.0 0.5 1403.91 2.0 0.4
R1_100_50_25 2277.23 13.0 87.9 2280.37 13.0 55.3 R2_100_50_25 1839.94 3.0 319.4 1894.98 3.0 146.4
R1_10_25_50 1768.21 11.2 <0.1 1768.21 11.2 <0.1 R2_10_25_50 1422.42 2.0 0.2 1422.42 2.0 0.1
R1_10_50_50 2514.09 14.6 1.2 2514.44 14.6 1.3 R2_10_50_50 1987.79 3.0 22.5 1990.36 3.0 19.6
R1_50_25_50 1841.61 11.9 0.1 1841.61 11.9 0.1 R2_50_25_50 1427.11 2.0 0.3 1427.11 2.0 0.3
R1_50_50_50 2578.36 15.0 1.1 2578.36 15.0 1.5 R2_50_50_50 2008.82 3.0 109.1 2012.62 3.0 64.6
R1_100_25_50 1849.74 12.0 0.2 1849.74 12.0 0.1 R2_100_25_50 1429.27 2.0 0.6 1429.27 2.0 0.6
R1_100_50_50 2585.9 15.0 2.1 2585.91 15.0 2.5 R2_100_50_50 2016.73 3.0 209.7 2023.12 3.0 143.5
R1_10_25_75 1864.59 11.8 <0.1 1864.59 11.8 <0.1 R2_10_25_75 1465.46 2.0 0.1 1465.46 2.0 0.1
R1_10_50_75 2662.81 15.2 1.2 2662.81 15.2 1.6 R2_10_50_75 2070.3 3.0 29.4 2072.35 3.0 15.9
R1_50_25_75 1897.98 12.0 <0.1 1897.98 12.0 0.1 R2_50_25_75 1575.2 2.0 0.2 1575.2 2.0 0.1
R1_50_50_75 2729.59 15.7 8.1 2729.71 15.7 8.1 R2_50_50_75 2198.52 3.0 47.6 2202.95 3.0 36.7
R1_100_25_75 1902.14 12.0 0.1 1902.14 12.0 0.1 R2_100_25_75 1607.69 2.0 0.1 1607.69 2.0 0.2
R1_100_50_75 2753.6 15.9 10.5 2754.7 15.9 17.2 R2_100_50_75 2255.6 3.0 51.8 2258.41 3.0 44.1
R1_10_25_100 1915.42 12.0 <0.1 1915.42 12.0 <0.1 R2_10_25_100 1649.84 2.0 <0.1 1649.84 2.0 <0.1
R1_10_50_100 2789.66 15.9 3.8 2790.43 15.9 5.0 R2_10_50_100 2332.59 3.0 7.6 2332.85 3.0 5.0
R1_50_25_100 1942.92 12.0 0.2 1942.92 12.0 0.1 R2_50_25_100 1673.05 2.0 <0.1 1673.05 2.0 <0.1
R1_50_50_100 2919.85 16.7 14.9 2920.75 16.7 13.4 R2_50_50_100 2377.33 3.0 2.6 2377.33 3.0 3.0
R1_100_25_100 1948.77 12.0 0.2 1948.77 12.0 0.3 R2_100_25_100 1677.35 2.0 0.1 1677.35 2.0 0.1
R1_100_50_100 2972.84 17.0 21.9 2973.6 17.0 18.5 R2_100_50_100 2384.34 3.0 29.2 2384.34 3.0 19.4

10
L. Wu and M. Hifi Computers & Industrial Engineering 145 (2020) 106491

Table 10
Behavior of GNS on instances of the last two classes RC1 and RC2 .
Inst. TTab NVab CPUab TTaa NVaa CPUaa Inst. TTab NVab CPUab TTaa NVaa CPUaa

RC1_10_25_25 941.13 5.0 0.4 941.15 5.0 0.4 RC2_10_25_25 1574.49 2.0 <0.1 1574.49 2.0 <0.1
RC1_10_50_25 1788.59 9.0 1.0 1788.6 9.0 1.9 RC2_10_50_25 2232.84 3.0 27.5 2249.47 3.0 19.7
RC1_50_25_25 958.07 5.0 0.1 958.07 5.0 0.1 RC2_50_25_25 1575.7 2.0 0.1 1575.7 2.0 0.1
RC1_50_50_25 1840.68 9.4 31.2 1855.16 9.7 10.1 RC2_50_50_25 2271.6 3.0 54.0 2273.09 3.0 33.7
RC1_100_25_25 959.83 5.0 0.1 959.83 5.0 0.2 RC2_100_25_25 1576.28 2.0 0.1 1576.28 2.0 0.2
RC1_100_50_25 1863.52 9.7 24.3 1868.48 9.8 15.8 RC2_100_50_25 2274.24 3.0 74.8 2275.28 3.0 74.2
RC1_10_25_50 1010.62 5.0 0.8 1010.65 5.0 0.7 RC2_10_25_50 1583.48 2.0 0.1 1583.48 2.0 0.1
RC1_10_50_50 2053.92 11.0 3.1 2054.04 11.0 4.2 RC2_10_50_50 2311.3 3.0 14.2 2311.81 3.0 12.8
RC1_50_25_50 1036.11 5.1 2.5 1039.33 5.1 1.6 RC2_50_25_50 1586.09 2.0 0.2 1586.09 2.0 0.2
RC1_50_50_50 2084.95 11.0 13.7 2084.98 11.0 9.1 RC2_50_50_50 2323.27 3.0 26.9 2323.49 3.0 24.2
RC1_100_25_50 1055.42 5.3 3.9 1055.69 5.3 2.6 RC2_100_25_50 1587.32 2.0 0.2 1587.32 2.0 0.3
RC1_100_50_50 2089.63 11.0 18.4 2089.65 11.0 18.5 RC2_100_50_50 2328.07 3.0 48.8 2328.11 3.0 47.8
RC1_10_25_75 1105.04 6.0 0.1 1105.04 6.0 0.1 RC2_10_25_75 1590.34 2.0 <0.1 1590.34 2.0 <0.1
RC1_10_50_75 2144.22 11.2 4.3 2144.29 11.2 4.1 RC2_10_50_75 2346.81 3.0 12.6 2347.14 3.0 11.8
RC1_50_25_75 1116.76 6.0 0.5 1116.76 6.0 0.4 RC2_50_25_75 1595.26 2.0 0.1 1595.27 2.0 0.1
RC1_50_50_75 2310.74 12.4 7.5 2310.89 12.4 8.6 RC2_50_50_75 2358.57 3.0 49.8 2358.74 3.0 47.1
RC1_100_25_75 1122.01 6.0 0.5 1122.01 6.0 0.5 RC2_100_25_75 1596.1 2.0 0.1 1596.1 2.0 0.1
RC1_100_50_75 2383.2 12.8 37.9 2383.39 12.8 26.8 RC2_100_50_75 2361.3 3.0 83.4 2361.61 3.0 70.7
RC1_10_25_100 1130.26 6.0 0.3 1130.26 6.0 0.3 RC2_10_25_100 1597.93 2.0 <0.1 1597.93 2.0 <0.1
RC1_10_50_100 2378.02 12.6 3.4 2378.02 12.6 2.6 RC2_10_50_100 2367.57 3.0 15.0 2368.07 3.0 14.1
RC1_50_25_100 1148.93 6.0 0.6 1148.96 6.0 0.3 RC2_50_25_100 1602.85 2.0 <0.1 1602.85 2.0 0.1
RC1_50_50_100 2567.9 13.9 15.7 2567.95 13.9 11.5 RC2_50_50_100 2382.16 3.0 2.3 2382.28 3.0 3.2
RC1_100_25_100 1155.67 6.0 0.3 1155.67 6.0 0.3 RC2_100_25_100 1605.85 2.0 0.1 1605.85 2.0 0.1
RC1_100_50_100 2642.86 14.6 26.9 2642.89 14.6 28.0 RC2_100_50_100 2385.07 3.0 9.0 2385.6 3.0 10.0

References problem with time windows. Networks, 49, 273–293.

Adida, E., & Perakis, G. (2010). Dynamic pricing and inventory control: Robust vs. sto-
chastic uncertainty models - a computational study. Annals of Operations Research,
181, 125–157.
Agra, A., Christiansen, M., Figueiredo, R., Hvattum, L., Poss, M., & Requejo, C. (2013).
The robust vehicle routing problem with time windows. Computers and Operations
Research, 40, 856–866.
Aissi, H., Bazgan, C., & Vanderpooten, D. (2009). Min-max and min-max regret versions
of combinatorial optimization problems: A survey. European Journal of Operational
Research, 197, 427–438.
Baldacci, R., Mingozzi, A., & Roberti, R. (2011). New route relaxation and pricing stra-
tegies for the vehicle routing problem. Operations Research, 59, 1269–1283.
Baldacci, R., Mingozzi, A., & Roberti, R. (2012). Recent exact algorithms for solving the
vehicle routing problem under capacity and time window constraints. European
Journal of Operational Research, 218, 1–6.
Bektaş, T., & Gouveia, L. (2014). Requiem for the miller-tucker-zemlin subtour elimina-
tion constraints. European Journal of Operational Research, 236, 820–832.
Ben-Tal, A., El Ghaoui, L., & Nemirovski, A. (2009). Robust Optimization. Princeton series in
applied mathematics. Princeton: Princeton University Press.
Ben-Tal, A., Goryashko, A., Guslitzer, E., & Nemirovski, A. (2004). Adjustable robust
solutions of uncertain linear programs. Mathematical Programming, 99, 51–76.
Bertsimas, D., Brown, D., & Caramanis, C. (2011). Theory and applications of robust
optimization. SIAM Review, 53, 464–501.
Bertsimas, D., & Brown, D. B. (2009). Constructing uncertainty sets for robust linear
optimization. Operations Research, 57, 1483–1495.
Bertsimas, D., & Sim, M. (2004). The price of robustness. Operations Research, 52, 35–53.
Bertsimas, D., & Simchi-Levi, D. (1996). A new generation of vehicle routing research:
Robust algorithms, addressing uncertainty. Operations Research, 44, 286–304.
Bouchakhchoukha, A., & Hifi, M. (2017). A hybrid descent method for the two-edge
disjoint survivable network design problem with relays. Computers & Industrial
Engineering, 112, 645–653.
Braaten, S., Gjønnes, O., Hvattum, L., & Tirado, G. (2017). Heuristics for the robust ve-
hicle routing problem with time windows. Expert Systems with Applications, 77,
136–147.
Gabrel, V., Murat, C., & Thièle, A. (2014). Recent advances in robust optimization and
robustness: An overview. European Journal of Operational Research, 235, 471–483.
Gendreau, M., Jabali, O., & Rei, W. (2016). 50th anniversary invited articleafuture re-
search directions in stochastic vehicle routing. Transportation Science, 50, 1163–1173.
Groer, C., Golden, B., & Wasil, E. (2010). A library of local search heuristics for the ve-
hicle routing problem. Mathematical Programming Computation, 2, 79–101.
Han, J., Lee, C., & Park, S. (2013). A robust scenario approach for the vehicle routing
problem with uncertain travel times. Transportation Science, 48, 373–390.
Hansen, P., Mladenović, N., Brimberg, J., & Pérez, J. (2010). Variable neighborhood
search. In M. Gendreau, & J. Y. Potvin (Eds.). Handbook of metaheuristics 146 (pp. 61–
86). Boston, MA: Springer.
Hu, C., Lu, J., Liu, X., & Zhang, G. (2018). Robust vehicle routing problem with hard time
windows under demand and travel time uncertainty. Computers and Operations
Research, 94, 139–153.
Kallehauge, B., Boland, N., & Madsen, O. (2007). Path inequalities for the vehicle routing
Kouvelis, P., & Yu, G. (1997). Robust discrete optimization and its applications. Boston:
Kluwer Academic.
M. Moradi, A. H., & Ghezavati, V. (2019). Robust resource-constrained project scheduling
problem of the project’s subcontractors in a cooperative environment under un-
certainty: Social complex construction case study. Computers & Industrial Engineering,
133, 9–28.
Marinakis, Y., Marinaki, M., & Migdalas, A. (2019). A multi-adaptive particle swarm
optimization for the vehicle routing problem with time windows. Information
Sciences, 481, 311–329.
Miller, C., Tucker, A., & Zemlin, R. (1960). Integer programming formulations and tra-
veling salesman problems. Journal of Association for Computing Machinery, 7,
326–329.
Alvarez, P. P., S.M., Espinoza, A., & Verab, J. (2019). Improving consistency in hier-
archical tactical and operational planning using robust optimization. Computers &
Industrial Engineering, 139, 106–112.
Pérez-Rodríguez, R., & Hernández-Aguirre, A. (2019). A hybrid estimation of distribution
algorithm for the vehicle routing problem with time windows. Computers & Industrial
Engineering, 130, 75–96.
Pisinger, D., & Ropke, S. (2010). Large neighborhood search. Handbook of
Metaheuristics. International Series in Operations Research & Management Science, 146,
399–419.
Quan, Z., & Wu, L. (2017). Cooperative parallel adaptive neighbourhood search for the
disjunctively constrained knapsack problem. Engineering Optimization, 49,
1541–1557.
Ritzinger, U., Puchinger, J., & Hartl, R. (2016). A survey on dynamic and stochastic ve-
hicle routing problems. International Journal of Production Research, 54, 215–231.
Roy, B. (2010). Robustness in operational research and decision aiding: A multi-faceted
issue. European Journal of Operational Research, 200, 629–638.
Shaw, P. (1998). Using constraint programming and local search methods to solve vehicle
routing problems. In CP-98 (Fourth International Conference on Principles and
Practice of Constraint Programming), Lecture Notes in Computer Science, 1520,
417–431.
Solano-Charris, E., Prins, C., & Santos, A. (2015). Local search based metaheuristics for
the robust vehicle routing problem with discrete scenarios. Applied Soft Computing,
32, 518–531.
Solomon, M. (1987). Algorithms for the vehicle routing and scheduling problems with
time window constraints. Operations Research, 35, 254–265.
Stenger, A., Vigo, D., Enz, S., & Schwind, M. (2013). An adaptive variable neighborhood
search algorithm for a vehicle routing problem arising in small package shipping.
Transportation Science, 47, 64–80.
Toth, P., & Vigo, D. (2014). Vehicle Routing: Problems, Methods, and Applications. SIAM.
Vidal, T., Crainic, T., Gendreau, M., & Prins, C. (2014). A unified solution framework for
multi-attribute vehicle routing problems. European Journal of Operational Research,
234, 658–673.
Vidal, T., Crainic, T. G., Gendreau, M., & Prins, C. (2013). A hybrid genetic algorithm with
adaptive diversity management for a large class of vehicle routing problems with
time-windows. Computers & Operations Research, 40, 475–489.
Wu, L., Hifi, M., & Bederina, H. (2017). A new robust criterion for the vehicle routing
problem with uncertain travel time. Computers & Industrial Engineering, 112, 607–615.

11