Engineering Applications of Artificial Intelligence 48 (2016) 119–133

Contents lists available at ScienceDirect

Engineering Applications of Artificial Intelligence

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

An ELS-based approach with dynamic probabilities management

in local search for the Dial-A-Ride Problem
M. Chassaing n, C. Duhamel, P. Lacomme
Université Blaise Pascal Laboratoire d'Informatique (LIMOS) UMR CNRS 6158, Campus des Cézeaux, 63177 Aubière Cedex, France

art ic l e i nf o a b s t r a c t

Article history: This paper addresses the Dial-A-Ride Problem (DARP) which is used to model on-demand transportation
Received 2 May 2015 services. This kind of transportation is quickly becoming an essential service for modern public mobility
Received in revised form or logistics providers. In the DARP, a set of transportation requests has to be handled by a fleet of vehicles.
21 September 2015
Each request corresponds to a client to be transported from a pickup point to a delivery point. The
Accepted 13 October 2015
routing costs have to be minimized, while respecting a set of constraints including time windows on
nodes, maximum riding time per client and a maximal total duration of trips.
Keywords: An Evolutionary Local Search (ELS) based approach is proposed to solve this problem. A new greedy
DARP randomized heuristic to compute initial solutions is developed. A dynamic probabilities management
ELS
mechanism is used in the local search to improve the convergence. The method is benchmarked on a
Metaheuristic
classic set of instances from the literature and it is compared against state of the art methods. The
Heuristic dynamic probabilities
numerical results show the effectiveness of this approach.
& 2015 Elsevier Ltd. All rights reserved.

1. Introduction
1.1. Vehicle Routing Problems
The generic problem under consideration in this paper is
related to the class of Vehicle Routing Problems (VRP), whose aim
is to meet the demand of a set of clients. Trips are performed by
vehicles initially located at a central depot and travels between
clients or from/to the depot use the least-cost routes. The basic
version of the VRP, the Capacitated VRP (CVRP), is often defined on
a complete undirected graph G ¼ ðX; EÞ. The node set X contains
n þ 1 nodes, one depot (node 0) and n customers indexed from 1 to
n. An unlimited fleet of identical vehicles with capacity Q is based
at the depot to deliver the demand qi of each customer i. The cost
cij to travel from node i to node j corresponds to the cost of a
shortest path from i to j in the real road network. The objective of
the VRP consists in finding a set of minimal cost trips to serve all
the customers taking into account the following constraints:
 deliveries cannot be split (each customer must be visited by a
single vehicle);
 each route starts and ends at the depot;
n
Corresponding author.
E-mail addresses: maxime.chassaing@isima.fr (M. Chassaing),
christophe.duhamel@isima.fr (C. Duhamel), placomme@isima.fr (P. Lacomme).
 the total demand of the customers served by one vehicle must
fit its capacity.
The VRP is NP-hard and exact methods require a large com-
putational time and can practically handle instances with up to
100 customers (Baldacci and Mingozzi, 2009). Among the current
best heuristic approaches for the VRP, hybrid genetic algorithms
are a good approach (Prins, 2004; Nagata and Bräysy, 2009; Vidal
et al., 2014). Furthermore, Mester and Bräysy (2007) propose a
very efficient metaheuristic that combines guided local search
with evolutionary strategies. Extensive research has been pro-
posed to solve this NP-hard problem, see the survey of Golden
et al. (2008).
1.2. Dial-A-Ride Problem
The Dial-A-Ride Problem (DARP) is a well-known extension of
the VRP. Thus, it is NP-hard. Instead of a delivery, each client
demand corresponds to a transportation request from a pickup
point to a destination point. Additional constraints such as time
windows on the pickup and delivery points, riding time for the
clients, total travel time and fleet size are also considered. Earliest
relevant publications date back from the 80s, focusing on the
special case with a single vehicle. Heuristic approaches have been
proposed including Bodin and Sexton (1986), Dumas et al. (1991),
Madsen et al. (1995), Psaraftis (1980) and Toth and Vigo (1996).
Yet, few publications focus on real-life instances. One can note the
contribution of (Rekiek et al., 2006) addressing Dial-A-Ride

http://dx.doi.org/10.1016/j.engappai.2015.10.002
0952-1976/& 2015 Elsevier Ltd. All rights reserved.
120 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

Problems in Bologna and (Borndörfer et al., 1999) which considers A solution s can be defined as the assignment of a permutation
the transportation of disabled persons in Berlin. Two main varia- node list λk to each vehicle k used such that every node i ¼ 1; …; 2n
tions on DARP can be found in the literature: transportation belongs to a permutation list and, for any transportation request ,
requests known in advance define the static DARP while the nodes i þ and i  belong to the same permutation list. Let nλ be the
dynamic DARP is dedicated to online transportation requests. The number of non-depot nodes of the permutation node list λ. Then,
later differs from the real-time DARP since the network does not if λðiÞ is the ith visited node, λð0Þ ¼ λðn þ 1Þ ¼ 0 is the depot node,
 
evolve over the time and decisions are not applied immediately. λð1Þ resp. λ nλ is the first resp. last visited node. Moreover Bλ is
We focus here on the static version of DARP.
the departure time from the depot and Eλ is the return time to the
More formally, the static DARP is defined on a complete
depot. Once permutation node lists are properly set, the arrival
weighted digraph G ¼ ðV; AÞ with a homogeneous fleet of K vehi-
cles and a set of n transportation requests. V ¼ f0; 1; …; 2n; 2n þ 1g times Ai and departure times Di can be computed. Let mðsÞ be the
is the set of nodes, including the depot, the pickup nodes and the number of vehicles used in the solution s. For convenience, let us
delivery nodes. The depot is split in two copies, 0 and 2n þ 1 for note λk the permutation list corresponding to the kth vehicle.
the depot respectively at the beginning and at the end of a trip. Thus, the objective of the DARP is to find a solution s of minimal
Given a transportation request i, its pickup point is referred as i P
mðsÞ P
ni
total travel cost cðsÞ ¼ cλk ðiÞλk ði þ 1Þ . Moreover, the following
and its delivery point is n þ i. Thus f1; …; ng is the subset of pickup k¼1i¼0
nodes and fn þ1; …; 2ng is the subset of delivery nodes. Note that criteria are associated measure the quality of a solution s:
i þ , resp. i  , are also used to denote the pickup point, resp. the P n 
P 

 n
delivery point, of transportation request i. For each node i, ei ; li is  the total riding time TRT ðsÞ ¼ Ri ¼ Bi þ n  Di ;
i¼1 i¼1
the time windows: ei is the earliest starting time and li is the latest P
m ðsÞ  
starting time. The service duration is di and qi is the number of  the total duration TDðsÞ ¼ E λk  B λk ;
k¼1
persons to transport. Given an arc ði; jÞ A A, t ij is the transportation P
2n P
2n
time and cij is the transportation cost. The capacity Q is the same  the total waiting time TWT ðsÞ ¼ Wi ¼ ðBi  Ai Þ.
i¼1 i¼1
for all the vehicles (homogeneous fleet).
Five main types of variables are used; their connection is illu- A solution must satisfy the following constraints:
strated in (Fig. 1). Given a node i, Ai is the arrival time of a vehicle,
Bi is the beginning of service and Di ¼ Bi þ di is the departure time (1) at any point of the trip, the number of persons transported by
of the vehicle. The waiting time W i is given by W i ¼ Bi  Ai . For a the vehicle is limited by its capacity Q ;
transportation request , the riding time Ri is the time duration (2) the beginning of service at node i fit the node's time window,
between the end of service at pickup node i þ () and the beginning i.e. ei r Bi r li ;
of service at delivery node i  (n þ i). Thus Ri ¼ Bn þ i  Di . Note that, (3) the riding Li for any client i does not exceed L;
as shown in Fig. 1, a service at node i may not begin at the earliest (4) the trip duration for any vehicle does not exceed the maximal
possible starting time ei , even if Ai oei , in order to satisfy the trip duration MaxTD ;
riding time constraints and the total duration constraint. (5) at most K vehicles must be used.
Each customer must be picked up at the pickup node and dropped
off at the delivery node. Each trip starts and ends at the depot. The As stressed by Cordeau and Laporte (2003), the constraints –
vehicle capacity constraint must hold anytime in the trip. Thus, for any especially (C2) and (C3) – can be tight. This limits the ability of
node , the number of persons qi to transport must not exceed the local searches to explore the solution space S. Thus, in several
vehicle available capacity. The beginning of service must satisfy the approaches, a partial relaxation has been proposed in order to


time windows, i.e. Bi A ei ; li . Waiting time is allowed before any allow the search in regions of non-feasible solutions. Given a
beginning of service and is forbidden after the end of service. For every solution s A S; the four following feasibility measures are defined:
node, the end of a service also corresponds to the departure time. The
riding time Ri of transportation request corresponds to the time spent  qðsÞ, total load violation;
by the associated clients in the vehicle. It cannot exceed a given upper  sðsÞ , total duration violation;
limit Li , i.e. Ri r Li . Such restriction models the quality of service from  wðsÞ, total time window violation;
the clients point of view.  t ðsÞ, total riding time violation.

Fig. 1. Description and notations.

 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133 121

Then, solutions are evaluated using a penalized cost function: 6. S: solution

7. Begin
f ðsÞ ¼ cðsÞ þ α:qðsÞ þ β :sðsÞ þ γ :wðsÞ þ τ:t ðsÞ 8. initialization of P: P ½i ¼ 0:25; 8 i ¼ 1…6
where α; β; γ; τ are positive penalty coefficients. Such relaxation 9. // step 1. Creation of one solution
mechanisms are commonly used to improve the exploration by 10 s:¼ randomized_constructive_heuristic()
local search methods of the solutions space. In the method we 11. s:¼ local_search(s,P)
propose, only feasible solutions are considered and the cost 12. // step 2.Improvement by ELS
function is as follows: 13. for i: ¼1 to ne do
(
cðsÞ if s is feasible 14. s0 : ¼s
f ðsÞ ¼ 15. for k: ¼1 to nd do
þ1 otherwise
16. s″:¼ mutation(s0 )
17. s″: ¼local_search(s″,P)
1.3. Contributions of the paper 18. end for
19. s:¼ best of all s″
In this paper, we propose an Evolutionary Local Search (ELS) 20. if (i mod nr) ¼0 then
metaheuristic for the static DARP. The initial solution is computed by 21. update(P);
a new randomized constructive heuristic before being submitted to 22. end if
the ELS. The local search within ELS combines six neighborhood 23. end for
structures. They are controlled by probabilities which are dynami- 24. return s
cally updated in order to improve the behavior of the ELS. Moreover, 25. End
we investigate the efficiency of the trip evaluation initially proposed
by Firat and Woeginger (2011) and we compare it with the classic
The algorithm corresponding to ELS iterates from lines 13 to 23.
trip evaluation from Cordeau and Laporte (2003).
The remaining of the paper is organized as follows: Section 2 is Each of the ne iterations consists in first creating a set of nd neigh-
dedicated to the ELS-based metaheuristic for computing solutions of bors (line 16) by mutation. Thereafter each neighbor is improved by a
good quality for the DARP. Classic and improved trip evaluations are local search (LS) procedure line 17. The best resulting solution is kept
presented, as well as the greedy randomized constructive heuristic line 19. The probabilities used in the LS for activating neighborhood
and the dynamic probability scheme used in the local search. Section structures are updated every nr iterations line 21.
3 reports the numerical results on instances from the literature. The The LS procedure is called on the solution in order to improve it
solutions computed by our approach are compared against the best until a local optimum is reached. It relies on several classical VRP
existing methods. Concluding remarks are set in Section 4. operators fully described in Braekers et al. (2014), Masson et al.
(2014), Lin and Kernighan (1973) and Potvin and Rousseau (1993).
Those operators correspond to six kinds of basic move, each one
2. Proposed ELS metaheuristic
start
The Evolutionary Local Search (ELS) has been first proposed by
Wolf and Merz (2007) and applied to VRP by Prins (2009). It is
basically an extension of the Iterated Local Search (ILS) defined by
DARP solutions
Lourenço et al. (2003). At each iteration of the ELS, several copies search space
of the current solution are built. Each copy is modified (mutation) randomized pickup
nodes order
before being improved by a local search. The best resulting solu-
tion is kept as the new current solution. The purpose of the ELS is S (solution)
Greedy heuristic
to better investigate the neighborhood of the current local opti- O : order of pickup nodes
mum before leaving it. It is often combined with a wider
exploration mechanism, like GRASP or a simple multi-start, to local search
manage the diversity during the global solution space exploration. ne ELS iterations
The framework we propose is an ELS which it is applied to the S’ (solution)
initial solutions generated by a greedy randomized heuristic. Such
an approach can be stated as a hybrid heuristic in which the ELS is mutation
used as local search applied on the initial solution (Fig. 2).
The scheme of the ELS is presented in Algorithm 1. The algo- S’’ (solution)
rithm starts by randomly creating an initial solution line 10. The
procedure Randomized_constructive_heuristic() first builds a
local search
neighborhood

permutation pickup nodes list before iteratively building a solu-

iterations

tion. Since the heuristic does not take the fleet size into account,
nd

S’’’ (solution)
the solution it provides may violate constraint (C5). Thus, Rando-
mized_constructive_heuristic() may be called until a solution
feasible wrt. (C5) is built. Those iterations are not mentioned to
keep readability but should be set line 10.
update the set of solutions (T’’)
Algorithm 1: ELS()
1. Input
2. nd: nb of neighbors best solutions

3. ne: nb of ELS iterations

4. nr: nb of iterations with same probabilities P end

5. Output Fig. 2. Framework principles.

122 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

representing a search direction. One activation probability is
associated to each operator and it is stored in the array P. Initially,
P[i] ¼ 0.25 is set as initial probability at step 8. As mentioned
before, the probabilities are updated every iterations. The update
takes into account the ability of an operator to improve the current
solution at the current iteration. Dynamically updating these
probabilities allows a strong convergence rate for each instance.
Efficient clone detection is set in order to prevent unprofitable
exploration in a region of the solution space already visited. Such a
mechanism is often used in practice by iterative search processes
(including genetic algorithm, tabu search, GRASP, etc.). Since full
clone detection can be time consuming, we propose a faster – yet
approximate – policy. It relies on hashing techniques (Cormen et
Table 1
Example of scheduling problem.
al., 1990) and it uses the total duration of the solution s with a
coefficient α along with the customers in first position and last
position of each trip. Note that Bi , the beginning service time of the
customer i at the middle of the trip, is also used in the hash
computation. Thus the hash formula is as follows:
!
mðsÞ 
X 
keyðsÞ ¼ α:cðsÞ þ λk ð1Þ:λk ðnk Þ þ Bλk ðnk =2Þ mod M
k¼1
M is a large integer, for example M ¼ 999999. The computation of
the key can be done during the solution evaluation without any
impact on the algorithm complexity. Each key is stored in an array
Clone such that Clone½α gives the number of visited solutions whose
key is α. Thus the clone detection can be performed in Oð1Þ. Using this
array, it is possible to control how many times the ELS is allowed to
consider a solution previously visited. This number is typically 1 or 2. A
check_Clone() function is used at each step of the algorithm.

Job Oi;1 Oi;2 Oi;3

2.1. Classic trip evaluation (Cordeau and Laporte, 2003)
1 ðm1 ; 10Þ ðm2 ; 35Þ ðm3 ; 25Þ
2 ðm1 ; 15Þ ðm3 ; 16Þ ðm2 ; 12Þ The evaluation introduced by Cordeau and Laporte (2003) takes
advantage of a graph where the starting service times are com-
puted by a shortest path algorithm. Such an approach is a special
case of the classical earliest starting time computation in sche-
M1 10 M2 35 M3 duling problems, usually done on disjunctive graphs.
0 25
12

0 10 2.1.1. Disjunctive graph in scheduling problems

*
16 The disjunctive graph has been first introduced by Roy and Sus-
0 15 16 12 smann (1964). Each operation is modeled by a node. A precedence
M1 M3 M2
constraint between two operations on different machines is repre-
Fig. 3. A fully oriented disjunctive graph. sented by an arc between the two associated nodes. A disjunctive

Fig. 4. Definition of the graph.

-50 -12

-36

-30 -6
-29
0
* 0 1 1+ 2
2+ 3 1- 2 2- 1
5
27 28 30 33 36 37
1
15 -5

26

36
Fig. 5. Example of graph (Cordeau and Laporte, 2003).
 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133 123

0 its cost
 is eλðiÞ ;
1+ 2+ 1- 2 2-
2 3 1
* 0 1 5  Arcs λðiÞ;  correspond to the latest starting time at node λðiÞ,
0 1 15 26 36 37
 is  lλðiÞ;
its cost 
1  Arcs λ βðiþ nÞ ; λðiÞ correspond to the maximal riding time of
i, its cost is –L;
15 transport request

 The arc λ nλ þ1 ; λð0Þ models the maximal trip duration, its
26
cost is MaxTD .
36  
Given a node iA H, let Γ i ¼ jA V j ðj; iÞ A A be its set of pre-
þ 
Fig. 6. Second step with constraints on ei and conjunctive arcs. decessor nodes and let Γ i ¼ j A V j ði; jÞ A A be its set of successor
nodes. For sake of simplicity, let vij be the value of the arc ði; jÞ A A as
defined before. Evaluating λ corresponds to compute a feasible start-
-50 ing service time Bi for every node iA H, with respect to all the con-
-36 straints represented by the arcs. This can be done by computing the
longest path from node 0 to any other node in G, using for instance a
-30 Bellman–Ford algorithm. Initially B0 ¼ B ¼ 0. Due to the maximal
-29 time lags, a longest path algorithm must be used to compute Bi . Given
0
* 0 1 1+ 2 2+ 3 1- 2 2- 1
5 the specific structure of the graph, the backward and forward time
27 28 30 33 36 37 slacks introduced by Savelsbergh (1992) allow a more efficient algo-
1 rithm than Caumond et al. (2008). This algorithm is fully described in
15 Cordeau and Laporte (2003). It provides the earliest Bi on nodes which
minimize the total riding time if a feasible solution exists.
26 This algorithm will be referred as Cordeau_evaluation(λ,A,D,B,W,F)
in the following. The sequence λ is the only input parameter. The
36
output parameters include the starting service times B, the waiting
Fig. 7. Third step with constraints on ei and conjunctive arcs. time on nodes W and the maximal delay on nodes F. Also note  that f
(λ):¼Cordeau_evaluation(λ,A,D,B,W,F) is the solution cost f λ .
Example:
constraint between two operations on the same machine is modeled In the example, i þ being the pickup node associated to client i and
by an edge. The cost of an arc is set to the duration of the beginning i  its delivery node, λ ¼ f0; 1; 2; 3; 4; 5Þ is identical to λ ¼ f0; 1 þ ;
operation. A solution consists in setting an orientation for each edge 2 þ ; 1  ; 2  ; 5Þ. Consider the permutation node list λ ¼ f0; 1 þ ; 2 þ ;
such that the resulting digraph is acyclic. 1  ; 2  ; 5Þ assigned to a vehicle and the following transportation
Let us consider the scheduling problem Table 1. The disjunctive times: t 0;1 þ ¼ 2; t 1 þ ;2 þ ¼ 2; t 2 þ 1  ¼ 3; t 1  2  ¼ 2; t 2  ;5 ¼ 1. For
graph of a solution is illustrated in Fig. 3. This graph is acyclic, all pairs simplicity, service times are set to 0. The maximal riding times are
of operations requiring the same machine (for instance 01;2 and 01;3 ) l1 ¼ 5 and l2 ¼ 6 for transport requests 1 and 2 respectively. The
have been oriented. Thus, the sequence of operations on any machine maximal trip duration is MaxTD ¼ 12.
is set. In this graph, an arc (in full line) between two consecutive According to the previous definitions, the graph of Fig. 5
  models the disjunctive graph of the problem. The bold numbers
operations Oi;j ; Oi;j þ 1 represents the routing constraint of the job i
(Table 1). It is evaluated by the minimal distance between the start near the nodes are the starting service times. Thus, the beginning
times of these two operations: i.e. the duration of Oi;j . A simplified times on nodes are restricted by the arcs ; λðiÞ A A : B1 þ ¼
version of Dijkstra shortest path algorithm is used to compute the 1; B2 þ ¼ 15; B1  ¼ 26; B2  ¼ 36. The total trip duration is Bλð6Þ 
Bλð0Þ ¼ 10 units of time.
earliest starting time of each operation.
The technique relying on disjunctive graphs has been extended
2.1.3. Cordeau and Laporte (2003) algorithm
over the years to handle minimal time lag and more recently
The tuned algorithm (see Algorithm 2) introduced by Cordeau
maximal time lag between operations (Caumond et al., 2008).
and Laporte (2003) contains four steps and computes the shortest
path minimizing the total riding time of the customers.
2.1.2. Application to the DARP
A dedicated disjunctive graph is used to evaluate a trip from a Algorithm 2: Cordeau_evaluation ()
solution. This is a special case of the previous approach since a 1. Input
single machine (the vehicle) is used. The permutation nodes list λ 2. λ: ordered set of nodes
corresponds to the sequences of nodes visited by the vehicle. 3. Output
 
Remember that λðiÞ is the ith visited node, λ nλ is the
 last node on 4. A: arrival time at nodes
which to perform an operation and λð0Þ ¼ λ nλ þ 1 is the depot 5. D: departure time at nodes
node. A function βðiÞ is defined on λ to give the position of element 6. B: earliest beginning of service time at nodes
 
i, such that λ βðiÞ ¼ i. The relative order between pickup and 7. W: waiting time at nodes
delivery nodes is assumed to hold, i.e. βði þnÞ 4 β ðiÞ. 8. F: forward time slack at nodes
The procedure proposed by Cordeau and Laporte (2003) for 9. Begin
evaluating a trip consists in first building an auxiliary acyclic graph 10. // Step 1: initialization
  
G ¼ ðH; AÞ. Given the sequence of nodes λ, H ¼ λð0Þ…λ nλ þ 1 ;  11. B0 : ¼ 0
where  is an additional dummy node. A contains arcs with the 12. // Step 2.
following definitions (Fig. 4): 13. Build G using the precedence constraints and ei
  14. for i:¼ 1 to nλ þ 1 do
 Arcs λðiÞ; λði þ 1Þ correspond to the vehicle trip from node λðiÞ  
15. BλðiÞ : ¼ max Bj þ vjλðiÞ
 λði þ 1Þ, its cost is dλðiÞ þt λðiÞ;λði þ 1Þ ;
to node 
j A Γ λðiÞ
 Arcs ; λðiÞ correspond to the earliest starting time at node λðiÞ, 16. end do
124 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

 
17. // Step 3. step, considering only nodes from positions β i þ to nλ . At the end
18. for i: ¼ nλ to 0 do of the process, if the starting time complies with the maximal time
 
19. BλðiÞ : ¼ minþ Bj  vλðiÞj lag, the arc modeling the maximal time lag is added into the graph
j A Γ λðiÞ line 37. Otherwise, a new maximal time lag corresponding to the
20. end do time gap between nodes i þ and i  is created. This value is the
21. for i:¼ 1 to nλ do smallest value of the maximal time lag which ensures an acyclic
 
22. BλðiÞ : ¼ max Bj þ vjλðiÞ graph. The riding time violation is the difference between the max-

j A Γ λðiÞ imal time lag added in the graph and the customer maximal riding
23. end do time. This violation helps updating
 t ðsÞ at the end of the algorithm.
24. // Step 4. The algorithm runs in O nλ 2 .
25. for each time lag Ri þ do Example:
26. //new beginning time The second step of the algorithm consists in considering the
 
27. for i:¼ nλ to β i þ do precedence constraints and the earliest starting time and to
  compute a longest path. The earliest beginning of service at nodes
28. BλðiÞ : ¼ minþ Bj  vλðiÞj  
j A Γ λðiÞ is computed considering BλðiÞ : ¼ max 
Bj þ vjλðiÞ which leads to
j A Γ λðiÞ
29. end do the solution Fig. 6.
30. // update earliest beginning time The third step of the algorithm consists in fixing the value Bλð5Þ
 
31. for i:¼ β i þ þ 1 to nλ do on the last node (5) then updating labels in the graph considering
 
32. BλðiÞ : ¼ max Bj þ vjλðiÞ the maximal time lag between each operation and the dummy

j A Γ λðiÞ node (). These maximal time lags model the latest starting time li
33. end do of each operation i. This is done by computing the latest starting
34. if (Bi   Bi þ 4 Ri þ ) then time, starting from the last node (5) back to the second node (0).
35. Ri þ : ¼ Bi   Bi þ The beginning of service at nodes is updated considering first
   
36. end if BλðiÞ : ¼ minþ Bj  vλðiÞj , then BλðiÞ : ¼ max Bj þ vjλðiÞ . This leads to

j A Γ λðiÞ j A Γ λðiÞ
37. Build G : ¼ G þRi þ
38. end do the solution Fig. 7.
39. update qðsÞ; dðsÞ; wðsÞ; t ðsÞ At the end of this part, the violation of constraints on the
40. update A; D; B; W ; F maximum duration can be computed. If the difference between
41. return cðsÞ the earliest starting time at node 5 and the latest starting time at
42. End node 0 is larger than TDmax then no feasible solution with respect
to the sequence λ exists. In Fig. 7, the service time at node 5 is 37
and the service times at node 0 is 27. This corresponds to a total
The first step (line 11) is the initialization phase. The second one duration of 10 units of time.
(lines 13–16) consists in computing the beginning of service con- The last step of the algorithm is a riding time enforcement
sidering only the precedence constraints and the earliest time win-
  procedure where all time lags are iteratively added into the graph.
dows of operations. This is done in O nλ time from dummy node  At each insertion of one maximal time lag, the beginning time of
 
to node nλ þ1, i.e. BλðiÞ : ¼ max
Bj þ vjλðiÞ . Eλ ¼ Bλðnλ þ 1Þ is the ear- transportation requests is updated to minimize the customer rid-
j A Γ λðiÞ
liest return time to the depot. The third step (lines 18–23) relies on a ing time. The updates are propagated over G. The maximal time
graph in which latest time windows are modeled by maximal time lags which model the maximal riding times are iteratively intro-
lags. The values of the beginning times are computed by duced into the graph using an approach similar to Caumond et al.
  (2008). They are set to the lowest maximal time lag leading to an
BλðiÞ : ¼ minþ Bj  vλðiÞj , starting from the node nλ (step 19). Thus,
j A Γ λðiÞ acyclic graph if a constraint violation occurs. The label propagation
BλðiÞ is the latest starting time of the service at node λi . It complies can be performed from the origin node of the arc to avoid a costly
with the earliest return time to the depot Bλðnλ þ 1Þ . Similarly, the and unproductive scan of G.
earliest starting time of service which complies to the latest starting The time lag from 1 þ to 1  does not update any label because
time of service at node 0 is computed step 22. The fourth step the maximal delay between the beginning time of 1 þ (B1 þ ¼ 28)
consists in solving the longest path on the full graph, sequentially and the beginning time of 1  (B1 þ ¼ 33) is 5, which is the max-
adding lines (25–38) the time lags which model the customer imal time lag. Similar remark holds for the second maximal
maximal riding time. Lines 27–33 use a process similar to the third time lag.

E +1) ( +1 )

l − π (2)
−π ( +1 )

l − π (1) (2) −π (2)

0 0 0 0 0 … 0
* λ(0) λ(1) λ(2) … λ(2)+n λ( +1)

−(e (2) −π (2) )

Fig. 8. Definition of the graph (Firat and Woeginger, 2011).

 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133 125

2.2. Improved trip evaluation (Firat and Woeginger, 2011)
Taking advantage of interval graph properties, the technique
introduced by Firat and Woeginger (2011) provides an evaluation
in linear time. This complexity is achieved by using the special
Union-Find structure as explained in Atallah et al. (1995). The
algorithm is composed of two steps:
Step 1: compute the maximal sum of waiting times on nodes,
while ending the trip at the earliest date;
Step 2: use the maximum waiting time to compute the begin-
ning of service Bi , the maximum forward time slack F i and the
other variables Ai ; W i ; Di for each node i.
Step 1 also checks the trip feasibility. Given the sequence λ ¼
 
0; 1; …; nλ ; nλ þ 1 of visited nodes, it consists in first building an
auxiliary acyclic graph G ¼ ðH; AÞ. H is the set of nodes, it contains
the nλ þ 2 nodes from λ as well as an additional dummy node . As
mentioned before, nodes 0 and nλ þ 1 correspond to the depot
node at the beginning, respectively the end of the trip (Fig. 8). The
following two extra notations are used:
P
i
 xλðiÞ ¼ W λðjÞ is the sum of the waiting times for the first i þ 1
nodes visited by the vehicle in λ;
j¼0
iP
1  
 π λðiÞ ¼ sλðjÞ þ t λðjÞλðj þ 1Þ is the sum of the service time and
j¼0
transportation time for all nodes before is the sum of the service
time and of the transportation time for all customers before λðiÞ.
 
 Arcs λðiÞ;  , with cost π λðiÞ  eλðiÞ , correspond to the earliest
starting time at nod λðiÞe. The beginning time BλðiÞ must be lar-
ger than the earliest starting time eλðiÞ , leading to the following
constraint: BλðiÞ Z eλðiÞ . Since BλðiÞ ¼ xλðiÞ þ π λðiÞ , this constraint
becomes: xλðiÞ Z eλðiÞ  π λðiÞ ;
 Arcs ; λðiÞ , with cost lλðiÞ  π λðiÞ , correspond to the latest
starting time at  node λðiÞ;
 Arcs λðiÞ; λðjÞ , with j ¼ βði þnÞ, correspond to the maximal
riding time of transportation request i. Since BλðjÞ  DλðiÞ Z L and
DλðiÞ ¼ BλðiÞ þ dλðiÞ ¼ xλðiÞ þ π λðiÞ þdλðiÞ , the following constraint
holds: xλðjÞ  xλðiÞ Z L  πλðjÞ þ π λðiÞ þ dλðiÞ ;
 The arc λðnk þ 1Þ; λð0Þ , with cost MaxTD  π λðnk þ 1Þ , models the
maximal trip duration. Using Bλðnk þ 1Þ ¼ xλðnk þ 1Þ þ π λðnk þ 1Þ and
Bλð0Þ ¼ xλð0Þ , the constraint Bλðnk þ 1Þ  Dλð0Þ r MaxTD becomes
xλðnk þ 1Þ  xλð0Þ r MaxTD  π λðnk þ 1Þ ;
The arc ; λðnk þ 1Þ corresponds to the largest time in the last
node of the trip. This arc is used to get the unique solution
which finishes at the earliest time. If the trip is feasible, such a
solution exists. The cost of this arc is Eλðnk þ 1Þ  π λðnk þ 1Þ , where
Eλðnk þ 1Þ is the earliest arrival time at the last node, considering
only precedence and smallest time constraints. Eλðnk þ 1Þ can be
computed in Oðnk Þ using Step 2 of Cordeau_evaluation().
In Step 1, G is first created. A variant of the shortest path
algorithm using the Union-Find data structure is applied. Setting

Note that the beginning of service can be rewritten with xλðiÞ :

BλðiÞ ¼ xλðiÞ þ π λðiÞ . A contains the set of arcs with the following
definitions (Fig. 8):
 
 Arcs λði þ1Þ; λðiÞ such that xλði þ 1Þ Z xλðiÞ . This means the sum of
the waiting times is an increasing function of λ; Fig. 11. Initial trips λ1 and λ2 .

37-9=28
12-9=3
50-8=42
36-6=30
30-3=27 (6-5) = 1
29-1=28
0
1+ 2+ 1- 2-
0 0 0 0
* 0 0 5
27 27 27 27 28 28
-(1-1)=0 5-5=0
-(15-3)=-12

-(26-6)=-20
Fig. 12. Scan for creation of t 1 .

-(36-8)=-28

Fig. 9. Example of graph (Firat and Woeginger, 2011).

Fig. 10. D-partition on the example. Fig. 13. Scan for creation of t 2 .
126 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

Algorithm 3. Starting from an empty solution (line 6), the trans-

Fig. 14. Final trips t 1 and t 2 .
portation request ði; iþ nÞ corresponding to the current pickup
node i A Λ is iteratively inserted into s (lines 7–28). The list E of
possible insertion positions for i and i þ n is first cleared (line 8).
Feasible insertion schemes for ði; i þ nÞ will be inserted into E and
sorted according to the evaluation of the resulting trip. Then, the
pickup node i is checked for insertion for every trip and every
location compatible with the order Λ (lines 9–11). This can be
anywhere after the last pickup in the trip. A dedicated procedure
p: ¼P(λ) returns the position of the last pickup in the permutation
list λ. Another procedure λ0 : ¼insert(i,λ,p) performs the insertion
of node i into λ at position p. It returns the modified permutation
list λ0 . Then, the delivery node iþ n is checked for insertion in
every position after i (lines 12 and13). The modified permutation
list λ' is evaluated by Firat_evaluation(). If a compatible time
assignment for the nodes in λ0 exists, λ0 is inserted into E. Once all
the positions have been investigated, an insertion scheme is ran-
domly selected if E a ∅ (lines 25 and 26) such that the ith element
in E has probability pð1  pÞi of being selected. Here, p ¼ 0:8. A new

trip 0; i; iþ n; 2n þ 1 is created and added to s otherwise (lines 22
and 23). Note that the computed solution is feasible with respect
to all constraints but (C5) as it may use more vehicles than
available.

Algorithm 3: Randomized_constructive_heuristic()
1. Input
2. Λ: permutation pickup nodes list
Fig. 15. Probabilities update scheme. 3. Output
4. s: solution
5. Begin
x ¼ 0; it computes xλðiÞ for any node λðiÞ A H. This corresponds to 6. s:¼ ∅
the latest possible starting time for each while ending the trip at 7. for all i A Λ do
 
the earliest time thanks to the arc ; λðnk þ 1Þ . If G contains a 8. E:¼ ∅
negative cost cycle, no solution to the shortest path exists, which 9. for k:¼1 to mðsÞ do
means no compatible arrival time can be set on the nodes. In Step 10. for p:¼P ðkÞ þ 1 to nλk do
2, xλðiÞ is used to compute the starting service time BλðiÞ ¼ xλðiÞ þ 11. λ0 :¼insert(i,λk ,p)
π λðiÞ , as well as the other variables, in Oðnk Þ. 12. for q: ¼p þ1 to nλ0k do
In the following, this algorithm is referred as Firat_evaluation
  13. λ0 : ¼ insert(iþ n,λ0 ,q)
(λ,A,D,B,W,F). Note that c λ is given by f(λ):¼Firat_evaluation(
 λ,A,
D,B,W,F) if λ is a feasible nodes ordering and f λ ¼ þ 1 otherwise. 14. f:¼Firat_evaluation(λ0 ,A,D,B,W,F)
Example 15. if (f a þ 1) then
 0 
Fig. 9 illustrates a graph generated according to the (Firat and 16. E : ¼ E [ λ ; k; f
Woeginger, 2011) algorithm on  the same instance that lead to 17. end if
Fig. 5. Given the node order ; λð0Þ…λðnk þ1Þ ¼ ; 0; 1 þ ; 2 þ ; 18. end do
1  ; 2  ; 5g, the computation of π gives π ¼ f0; 0; 1; 1 þ 2 ¼ 3; 1 þ 2 19. end do
þ 3 ¼ 6; 1 þ 2 þ3 þ 2 ¼ 8; 1 þ 2 þ 3 þ2 þ 1 ¼ 9g and the arc costs can 20. end do
be set. Then, given G, the shortest path from node  to all the other 21. if (E ¼ ∅)
nodes (Step 1) gives x ¼ f0; 27; 27; 27; 27; 28; 28 g. Step 2 leads to 22. λ: ¼new_trip(i,i þn)

B ¼ f0; 27 þ 0 ¼ 27; 27 þ 1 ¼ 23. s : ¼s [ λ
28; 27 þ 3 ¼ 30; 27 þ 6 ¼ 33; 28 þ 8 ¼ 36; 28 þ 9 ¼ 37g. 24. else
 
25. randomly select e ¼ λ; k; f A E
2.3. Randomized constructive heuristic 26. λk : ¼ λ
27. end if
We propose a two steps procedure to randomly generate fea- 28. end do
sible solutions to the static DARP. In the first step, a permutation 19. return s
list of the pickup nodes is built. Then, the construction scans the 20. End
list and iteratively schedules the transportation request corre-
sponding to the current pickup node to the best possible place.
Thus the main part is the second step. Its algorithmic scheme is
shown in Algorithm 3, while the construction of a randomized 2.3.2. Randomized generation of a permutation list Λ
permutation list is presented in Algorithm 4. As mentioned before, the constructive heuristic relies on a
permutation list Λ of the pickup nodes. It is built by the procedure
2.3.1. Constructive heuristic generate_sequence(), see Algorithm 4, and the construction is
Given a permutation list Λ of the pickup nodes f1; …; ng, the done in three steps. The first step consists in checking precedence
heuristic iteratively build a feasible solution s as shown in constraints between pickup nodes. Considering the set N ¼
 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133 127

f1; …; ng of pickup nodes, the algorithm scans all pairs in N and return value is set, depending on test1 and test2 (1 if i must be
calls check_constraint() line 9 to determine those constraints. This before j, 2 if j must be before i and 3 otherwise).
procedure returns 1 if the pickup node i must be set before the
Algorithm 5: check_constraint()
pickup node j, 2 if j must be set before i and 3 if i and j are 1. Input
not bound. 2. i: pickup node
This step corresponds to building a graph G ¼ ðV; EÞ with V ¼ 3. j: pickup node
N [ f0; g the set of pickup nodes plus two dummy nodes, 0 and . 3. Output
E is the set of arcs, an arc ði; jÞ A E modeling a precedence from 4. res: status (1-4 (i,j), 2-4(j,i), 3 otherwise)
pickup node i to j. Arcs ð0; iÞ and ði; Þ are first set for any node i A N. 5. Begin
6. // Part 1
Algorithm 4: generate_sequence()
7. test1: ¼ false
1. Input
8. i: ¼1;
2. N: set of pickup nodes
9. while (test1 ¼false) and (i o4) do
3. Output
10. f(λi):¼ Firat_evaluation(λi,A,D,B,W,F)
4. Λ: ordered set of pickup nodes
5. Begin 11. if (f(λi ¼ þ 1) then
6. // Step 1 12. i:¼iþ 1
7. for all i A N do 13. else
8. for all j A N do 14. test1:¼true
9. res:¼ check_constraint(i,j) 15. end if
10. if (res¼ 1) then 16. end do
11. add_arc(G,i,j) 17. // Part 2
12. else if (res¼2) then 18. test2:¼false
13. add_arc(G,j,i) 19. i:¼4;
14. end if 20. while (test2¼false) and (io 7) do
15. end do 21. f(λi):¼Firat_evaluation(λi,A,D,B,W,F)
16. end do 22. if (f(λi ¼ þ1) then
17. // Step 2 23. i:¼ iþ1
18. V0 : ¼compute_partition(G) 24. else
19. // Step 3 25. test2: ¼true
20. Λ:¼ random_generation(V0 ) 26. end if
21. return Λ 27. end do
22. End 28. // Part 3
29. if (test1¼ true) and (test2 ¼false) then
30. return 1
Step 2 consists in computing a partition V 0 of V, that is a set 31. end if
0
V ¼ fV 1 …V r g of r pairwise disjoint non-empty subsets of V such 32. if (test1¼false) and (test2 ¼true)then
that V ¼ [ ri ¼ 1 V i . This partition is computed by the procedure 33. return 2
compute_partition() line 18. V 0 is then used Step 3 to randomly 34. end if
build a permutation list Λ of pickup nodes. This is done by the 35. return 3
procedure random_generation() line 20. 36. End

2.3.3. Checking precedence constraints between pickup nodes

The procedure check_constraint(i,j) investigates all possible
2.3.4. Nodes partitioning
permutations involving transportation requests i and j, i.e. nodes i, Given two nodes i and j in G, let the distance from i to j be the
i þ n, j, jþ n. For convenience, they are respectively referred as i þ , number of arcs in the longest path from i to j. Let a d-partition
i  , j þ and j  . Given i and j, there are six possible permutations λt , 
    V 0 ¼ V 1 ; …; V k be a partition of V such that the distance from
t ¼ 1…6. The first three are such that β i þ o β j þ , the remaining node 0 to any node in V d is d. The procedure compute_Partition(),
 þ  þ
three are such that β i 4 β j : Algorithm 6, computes such a d-partition. It first starts with an
  empty d-partition, line 6. Then, the subsets V k are iteratively filled,
 λ1 ¼ i þ ; j þ ; i  ; j   starting from k ¼ 0. Given the current iteration k, it inserts into
 λ2 ¼ i þ ; i  ; j þ ; j   
subset V k all the nodes iA N such that Γ i ¼ ∅. Those nodes are
 λ3 ¼ i þ ; j þ ; j  ; i   then removed from N before starting the next iteration. Thus Γ j

 λ4 ¼ j þ ; i þ ; j  ; i   may be updated for the remaining nodes j A N.
 λ5 ¼ j þ ; j  ; i þ ; i  
 λ6 ¼ j þ ; i þ ; i  ; j  Algorithm 6: compute_partition()
1. Input
In the first part of check_constraint(), the feasibility of the first 2. G: graph of the pickup nodes
   
three permutations (β i þ o β j þ ) is investigated, lines 8–16 of 3. Output
Algorithm 5. A successful call to Firat_evaluation() for one of λ1 … 4. V0 : d-partition of V
λ3 means that DARP constraints holds for this permutation. Thus i 5. Begin
can be set before j in Λ and test1 ¼true. Similarly, the last three 6. k:¼0; Vk:¼Ø
    7. while (NaØ) do
permutations (β i þ 4 β j þ ) are checked in the second part lines
18–27 and one successful evaluation by Firat_evaluation() means j 8. for all iA N do
9. if ðΓ i ¼ ∅Þ then
can be set before i in Λ and test2¼ true. In the third part, the
128 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

10. Vk ¼ Vk [ {i} Table 2

11. N ¼N\{i} Set of instances.
12. end if
Instances Cordeau and Ropke et al. Ropke et al.
13. end for publications Laporte (2003) (2007) Part A (2007) Part B
14. k:¼k þ1
15. end while Cordeau and X
16. return V0 Laporte (2003)
Ropke et al. (2007) X X
17. End Parragh et al. X
(2010)
Parragh and X X X
Schmid (2013)
2.3.5. Random generation of a permutation pickup nodes list Masson et al. (2014 X
Given the d-partition computed in Algorithm 6, a straightfor- Braekers et al. X X
(2014)
ward deterministic approach would be to scan the nodes of the Our method X X X
subsets Vk, starting from k¼ 0, and append them into Λ. This
approach is randomized in algorithm 7. All subsets are scanned

lines 7–13 and the nodes in the current subset are inserted in a  V 1 ¼ 1 þ ; 3 þ ; 4 þ ;
random order into Λ.  V 2 ¼ 2 þ ; 5 þ ;
 V3 ¼ 6þ
Algorithm 7: random_generation ()
1. Input
Using this d-partition, the procedure random_generation()
2. V0 : d-partition builds a permutation of the pickup nodes, for instance Λ ¼
3. Output  þ þ þ þ þ þ  
1 ;3 ;4 ;2 ;5 ;6 or Λ ¼ 3 þ ; 1 þ ; 4 þ ; 5 þ ; 2 þ ; 6 þ .
4. Λ: permutation list of pickup nodes
5. Begin
2.4. Mutation
6. Λ:¼Ø; p:¼ 1
7. for k:¼1 to |V0 | do The mutation is an operator first proposed for the genetic
8. for all jA Vk do
algorithms and also used in the ELS (Algorithm 1). It consists in
9. i:¼ randomly pick one node in Vk
 applying a perturbation on a solution s in order to create a new
10. Λ: ¼ Λ[ i solution s' sharing some similarities with s. Here, it is based on two
11. p:¼ pþ 1 operations which are applied with respective probabilities 0:7 and
12. end for 0:3:
13. end for
14. return Λ  move 1: one transportation request ði; i þ nÞ is removed from its
15. End trip and inserted into another trip;
 move 2: transportation requests are exchanged between
two trips.
Example
Let us consider a DARP with six transportation requests. In
This second operation is an adaptation of the crossover
order to build the graph G, Algorithm 4 requires the identification
operator. Let λ1 and λ2 , of respective length nλ1 and nλ2 , be two
of precedence constraints between every pair of pickup nodes.
 permutation lists corresponding to two trips. Positions p1 and p2
Starting with pickup nodes 1 and 2, let 1 þ ; 1  ; 2 þ ; 2  be the set
are randomly chosen respectively in λ1 and λ2 , such that
of corresponding nodes with earliest starting times e ¼ 1 r pk r nλk , k ¼ 1; 2. All transportations requests i ¼ ði; i þ nÞ such
ð10; 15; 16; 20Þ and latest starting times l ¼ ð20; 35; 25; 33Þ. The that β ðiÞ r p1 and βði þ nÞ 4 p1 are tagged true. They correspond to
following transportation times are as follows: t 1 þ 1  ¼ 5, transportation requests whose pickup is before position p1 and
t 1 þ 2 þ ¼ 7,t 1 þ 2  ¼ 8; t1  2 þ ¼ 3; t 1  2  ¼ 10; t 2 þ 2  ¼ 2. They are delivery is after. Same for the second trip. All nodes of λ1 before p1 ,
supposed symmetric, i.e. t ij ¼ t ji . Algorithm 5 evaluates the six associated to untagged transportation requests, are iteratively
possible acyclic disjunctive graphs with respect to transportation inserted into the new trip t 1 . Then, all nodes of λ2 after p2 , asso-
requests 1 and 2: ciated to untagged transportation requests, are iteratively inserted
  into the new trip. Duplicates are discarded. The roles of λ1 and λ2
 λ1 ¼ 1 þ ; 2 þ ; 1  ; 2  -success are swapped to build the other new trip t 2 . Tagged transportation
 λ2 ¼ 1 þ ; 1  ; 2 þ ; 2  -success requests are inserted one by one in one trip at the best position
 λ3 ¼ 1 þ ; 2 þ ; 2  ; 1  -success considering the trip cost.
 λ4 ¼ 2 þ ; 1 þ ; 2  ; 1  -fail For instance, consider two trip Fig. 11 with respective cut
 λ5 ¼ 2 þ ; 2  ; 1 þ ; 1  -fail position p1 ¼ 2 and p2 ¼ 3. Nodes 1 þ ; 3 þ ; 3  ; 1  ; 6 þ ; 6  are tag-
 λ6 ¼ 2 þ ; 1 þ ; 1  ; 2  -fail ged because their pickup and their delivery is separated by the cut.
  They are displayed in gray. In Fig. 12, trip λ1 is scanned from
Permutations λα ¼ 2 þ ; 1 þ ; x ; x fail because the time window positions 1 to 2. Nodes 1 þ and 3 þ are not inserted into t 1 since
on 1 prevents 2 from being visited before. Thus 2 þ cannot be
þ þ
they correspond to tagged transportation requests. Then positions
set before 1 þ in Λ and check_constraint() returns 1. As a con- 4 to 6 are scanned in λ2 . Nodes 7 þ and 7  are inserted into t 1 , but
sequence, the precedence constraint (1 þ ; 2 þ Þ is inserted into G. not 6  .
This process is iterated for all pairs of pickup nodes. Suppose the
        By exchanging the role of λ1 and λ2 , we obtain the partial trips
precedence constraints 1 þ ; 2 þ , 3 þ ; 2 þ , 4 þ ; 5 þ and 5 þ ; 6 þ t 1 and t 2 shown Fig. 13.
have been added into G. The procedure compute_partition() is To conclude, all tagged nodes are scanned and inserted into the
called next and returns the following d-partition (see Fig. 10): trips (Fig. 14).
 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133 129

2.5. Local search The moves in the neighborhood structures have been adapted
to the DARP the same way it has been done in the mutation. The
The local search is an iterative improvement process. It mainly procedure 4_Opt() implements the operator proposed by Lin and
tries to reduce the solution cost f ðsÞ by exploring neighborhoods of Kernighan (1973). In the original k-opt operator, k arcs are
the current solution and selecting an improving solution. It relies removed from a trip and all possible ways to reconnect the
on the first improvement selection strategy and uses classical remaining segments are investigated. In the restricted version
moves first proposed for the VRP. It is limited to nls iterations or used here, only four successive arcs of a trip are removed at a time.
npi iterations without any improvement. The procedure Local_- The procedure cut_and_paste() uses the same trip modifications
mutation uses in order to remove a bloc of consecutive transpor-
Search(), shown in Algorithm 8, is composed of two parts. It
tation request from a trip an insert it into another trip. The pro-
includes the following features:
cedure worst_customer_ejection() consists in first removing the
transportation request from one trip, responsible of the largest
 A set of six basic moves are used with a given probability from
detour. Then it is inserted into another trip, at the best position.
lines 16–33;
This move is the combination of the Worst Removal and Best
 More than one move can be done in each iteration, since the
Insertion operators introduced by Masson et al. (2014). The pro-
probability checks are done sequentially;
 The arrays Succ[] and Fail[] are updated in order to keep the cedure relocate() implements the relocate operator (Braekers
et al., 2014). It removes a transportation request from its trip and
respective number of times each move has contributed to an
reinserts it into another trip, at the best possible position. Thus,
iteration with an improvement or not.
worst_customer_ejection() is a special case of relocate(). The
procedure 2_Opt*() implements the operator proposed by Potvin
Algorithm 8: local_search()
and Rousseau (1993). It removes an arc from two trips and
1. Input
recombines the resulting parts. It can be seen as a special case of
2. s: solution
the mutation presented earlier. The procedure exchange() swaps
3. P: array of probabilities
two transportation requests from different trips (Braekers et al.,
4. Output
2014).
5. s: solution
6. global parameters
2.6. Probability update scheme
7. nls: maximal number of iterations
8. npi: number of consecutive iterations without
The procedure update() takes into account the arrays Succ[]
improvement
and Fail[] in order to compute the new probability P[]. The number
9. Succ: array of success
of times move i has been called is n½i ¼ Succ½i þ Fail½i. Then, q½i
10. Fail: array of fail
11. Begin ¼ Succ½i=n½i is the ratio of calls which contributed to an
12. j:¼0; na: ¼ 0 improvement during the local search. Let qmax ¼maxðqi Þbe the
i
13. while ðj o nlsÞ and ðna rnpiÞ loop largest ratio. The new probability for each move is defined as:
14. s0 : ¼s  
P 0 ½i ¼ max 0:05; 95qi =qmax
15. T½i : ¼ 0; 8 i ¼ f1; :::; 7 g
16. with probability P[1] The update is illustrated in Fig. 15.
17. s0 :¼4_Opt(s0 )
18. T[1]: ¼ 1
19. with probability P[2] 3. Numerical experiments
20. s0 :¼cut_and_paste(s0 )
21. T[2]:¼1 The method is benchmarked over the 20 instances introduced
22. with probability P[3] by Cordeau and Laporte (2003) and 42 instances of Ropke et al.
23. s0 :¼worst_customer_ejection(s0 ) ( 2007). To provide a fair comparative study, the computational
24. T[3]: ¼1 time of each method has been scaled by the speed factor pre-
25. with probability P[4] sented Table 3. This coefficient takes into account the MIPS per-
26. s0 :¼relocate(s0 ) formance of each processor. Table 3 reports the information
27. T[4]:¼ 1 available about the last publications, including the operating sys-
28. with probability P[5] tem, the language and the processor used. Using Dongarra (2014)
29. s0 :¼2_Opt*(s0 ) one can estimate the computational power in terms of MFlops and
30. T[5]:¼ 1 to evaluate each speed factor. No MFlops are reported in Table 3
31. with probability P[6] for Masson et al. (2014) and Braekers et al. (2014) because no
32. s0 :¼exchange(s0 ) information could be found in Dongarra (2014) or on the web site
33. T[6]: ¼1 of the Linpack (www.roylongbottom.org.uk).
34. if (f(s0 )4f(s)-epsilon) then All methods use the instances from Cordeau and Laporte, with
35. na:¼na þ 1; the exception of Ropke et al. (2007) which used another set of
36. 8 i ¼ f1; :::; 7 g suchthat T ½i ¼ 0; Fail½i : ¼ Fail½i þ 1 instances. Only Parragh et al. (2010) and Parragh and Schmid
37. else (2013) reports result on both instances sets. In the remaining, to
38. na:¼0; s:¼s0 favor fair comparative study, the method we promote is bench-
39. 8 i ¼ f1; :::; 7 g suchthat T ½i ¼ 1; Succ ½i] :¼ Succ ½i]þ 1 marked on those two sets (Table 2). Note that the set of Ropke
40. end if et al. (2007) is usually split in two; part A and part B. Part A
41. j:¼j þ1 contains instances with smaller vehicle capacity (Q ¼ 3Þ while
42. end loop vehicles have a larger capacity (Q ¼ 6Þ in part B.
43. End In Tables 4–8, results are reported with 5 runs for each method.
The column gap corresponds to the average (over the 5 runs)
130 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133

Table 3
Relative performances of computers (http://www.roylongbottom.org.uk/linpack%20results.htm).

Cordeau and Laporte Ropke et al. Parragh et al. Parragh and Schmid Masson et al. Braekers et al. Proposition
(2003) (2007) (2010) (2013) (2014) (2014)

s s
Computer PIV 2 GHz Opteron Pentium D Xeon CPU at 2.67 GHz Intel CoreTM i3- 2.6 GHz Intel Core Intel CoreTM i7-3770 CPU @
2.4 GHz 3.2 GHz 530 laptop 3.40 GHz
OS / Linux / / Linux / Windows 7
Language / Cþ þ Cþ þ Cþ þ Cþ þ Cþ þ Cþ þ
MFlops 533 1291 630 1144 ? ? 2529
Speed 0.21 0.51 0.24 0.45 / / 1
factor

Table 4 Table 7
Comparative study with Parragh and Schmid (2013). Comparative study on Ropke et al. (2007) part A instances.

gap Avg. time Scale. time gap Avg. time Scale. time

Parragh and Schmid (2013) 1.58 21.84 9.88 Ropke et al. (2007) 0.01 63.30 13.38
Our method 0.85 9.87 9.87 Parragh and Schmid (2013) 0.17 2.26 1.02
Our method 0.07 1.02 1.02

Table 5
Relative performance of computers.
Table 8
gap Avg. time Scale. time Comparative study on Ropke et al. (2007) part B instances.

Cordeau and Laporte (2003) 1.11 338.82 71.63 gap Avg. time Scale. time
Parragh et al. (2010) 1.58 133.30 33.24
Parragh and Schmid (2013) 1.58 21.84 9.88 Ropke et al (2007) 0.00 56.30 11.90
Masson et al. (2014) 1.15 40.12 – Parragh and Schmid (2013) 0.12 2.25 1.02
Braekers et al. (2014) 0.97 1.39 – Braekers et al. (2014) 0.12 0.51 /
Our method 0.85 9.87 9.87 Our method 0.05 1.02 1.02

 
Table 6 complexity in O nλ . On the other hand, the algorithm from Cor-
Number of best solutions found. deau and Laporte behaves sublinearly. Its theoretical time com-
 
plexity is O n2λ .
Nb. of best solutions found on average
About the probability update scheme, the initial probability of
(column gap)
each move in the local search has been set to 0.25, according to a
Cordeau and 7 calibration test done on a subset of instances. Such an approach
Laporte (2003) means that the probabilities are not tuned for one instance
Parragh et al. (2010) 3
although a careful assignment of values to these probabilities
Parragh and Schmid 2
(2013) could have a significant impact on the convergence rate. The ori-
Masson et al. (2014) 2 ginality of the approach consists in including a dynamic prob-
Braekers et al. 8 ability management to self-adjust them during the iterations of
(2014)
the metaheuristic.
Our method 12
Fig. 17 gives a graphical comparison of two trajectories of the
ELS. The first one does not include any dynamic probabilities
management while the second one uses it. For convenience, the
probabilities were set to 0.25 in the ELS without probability
relative gap of the solution found by one method with respect to management.
the best known solution. The detailed results are available on the The two curves are nearly identical in the first third of the
website: http://fc.isima.fr/  chassain/Phd/ELSapproachDARP.php. evolution. A significant difference appears after 15 s and the con-
vergence rate appears to be better for the ELS with probability
3.1. Impact of the evaluation from Firat and Woeginger (2011) and of management. At the end of the run, the result it obtains in 20 s is
the probability update scheme better than the result the ELS with no probability management
gets in 1 min. The probability curves with respect to the time are
We first report a comparison (Fig. 16) of the time efficiency for quite similar for all instances of the same benchmark. For example,
the algorithms proposed respectively by Cordeau and Laporte Fig. 18 illustrates the probabilities for the instance r10a (Cordeau
(2003) and by Firat and Woeginger (2011) on instance 6 from and Laporte, 2003). As stressed on Fig. 19, the probability P ½1
Cordeau and Laporte. Trips have randomly generated and checked associated to move 4-opt rises to 0.95 after less than 10 s, while
separately on each method. Those can be feasible or infeasible. the probability P ½6 for the exchange (2 customers swap) drops to
This covers every cases in the algorithms. 0.05. The global evolution looks similar for Fig. 20.
For a moderate number of transportation requests, the differ- For the instances r10a, the probabilities P2, P3, P4 seem to have
ence is quite marginal. However, the later approach performs an asymptotic convergence to about 0.1, 0.35 and 0.7 respectively.
better as the number of transportations requests increases. Its These probabilities are 0.1 higher for the instances r4a but have a
practical performance is linear and matches the theoretical time very similar global trend. Similar remark holds for Fig. 21 about
 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133
Fig. 16. Comparison of the two evaluation algorithms.
Fig. 17. Convergence curve on instance r3a.
the instance r4b. The stationary probabilities are quite different for
the instance of Ropke et al. (2007): in these instances, the higher
probability is for P5 (i.e. 2 opt move) and the relative order of P2,
P3 and P4 is different. Note that the low influence of move
exchange (customer swap) holds for all instances considered.
To conclude, these experiments allows us to consider the
dynamic probabilities management as a strong feature to improve
the convergence. Moreover, it reduces the impact of the tuning
during.
3.2. Comparative study with Parragh and Schmid (2013): Cordeau
and Laporte' instances
We report the performances of the ELS considering the same
total computational time than (Parragh and Schmid, 2013) in order
to provide a fair comparative study with the previously published
methods. Considering the speed factor of 0.45 for the computer
used in Parragh and Schmid (2013), a computational time of
21.84 min is equivalent to 9.88 min on the computer used for this
study (9:89 min ¼ 21:84  0:45).
Assigning 10 min of computational time to the ELS leads to an
average gap about 0.80% which is quite better than the 1.58%
deviation from Parragh and Schmid (2013).
131
Fig. 18. Probability evolution for (Cordeau and Laporte, 2003) r10a.
3.3. Comparative study with previous articles: Cordeau and Laporte'
instances
About the average gap of methods over 5 runs, the average
deviation of the ELS is around 0.85. This is the best average
deviation over the five methods. With the exception of the method
from Braekers et al. (2014), the ELS is one of the most time-
efficient method. Note that the average time of 1.39 s for Braekers
et al. (2014) cannot be fairly compared since their speed factor is
unknown. However, note that the methods introduced by Masson
et al. (2014) and Braekers et al. (2014) are no dedicated to the
DARP and can address a wider spectra of problems.
On average our method appears to be slightly more efficient
than Braekers et al. (2014) with a gap of 0.85%, even if the times
cannot be compared. Furthermore our ELS approach provides 13
times the best gap (Table 6) on the 20 instances compared to the
five other methods. Considering the number of best solutions
found on average (column gap), the method we propose outper-
forms all previous methods.
3.4. Comparative study with previous articles: Ropke et al. (2007)
(part A)
The instances of (Ropke et al., 2007) part A are all solved to
optimality as stressed in Parragh et al. (2010).
132 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133
For both quality of result and computational time, the method
outperforms the previous ones with an average gap of 0.07% for
the 21 instances of (Ropke et al., 2007) part A.
3.5. Comparative study with previous articles: Ropke et al. (2007)
(part B)
The instances of (Ropke et al., 2007) part B are all solved to
optimality as stressed in Parragh et al. (2010). Similar comments
from the previous section hold for instances (Part B) proposed by
Ropke et al. (2007). Thus the best methods are the ELS we intro-
duce and the Ropke et al. (2007) method. The ELS is 10 times faster
with an average scaled time of 1 min compared to the 11 min
required by Ropke et al. (2007) method.
4. Concluding remarks
In this paper, we have introduced and benchmarked an ELS
framework for the static Dial-A-Ride Problem (DARP). It combines
a dynamic probabilities management to improve convergence
with a neighborhood search to perform an efficient exploration of
the search space. Both evaluation functions from Cordeau and
Laporte (2003) and Firat and Woeginger (2011) have been imple-
mented and compared. The results show the latter approach is
more interesting in terms of computational time. In addition, the
proposed method includes other original points:
Fig. 19. Probability evolution for (Cordeau and Laporte, 2003) r4a.
Fig. 20. Probability evolution for (Cordeau and Laporte, 2003) r4b.
Fig. 21. Probability evolution for (Ropke et al., 2007) a7-84.
1. An initialization procedure which is based on graph partition.
2. A new efficient mutation procedure.
3. A local search method which includes dynamic probabilities
management for the different moves.
The obtained results indicate that using the method we obtain
better results than previously published ones in a rather short
computation time.
References
Atallah, M.J., Chen, D.Z., Lee, D.T., 1995. An optimal algorithm for shortest paths on
weighted interval and circular-arc graphs, with applications. Algorithmica 14,
429–441.
Baldacci, R., Mingozzi, A., 2009. A unified exact method for solving different classes
of vehicle routing problems. Math. Program. 120, 347–380.
Bodin, L.D., Sexton, T., 1986. The multi-vehicle subscriber Dial-A-Ride Problem.
TIMS Stud. Manag. Sci. 22, 73–86.
Borndörfer, R., Grötschel, M., Klostermeier, F., Küttner, C., 1999. Telebus Berlin:
Vehicle Scheduling in a Dial-a-Ride System. In: Wilson, P.N.H.M. (Ed.), Com-
puter-Aided Transit Scheduling, Lecture Notes in Economics and Mathematical
Systems. Springer, Berlin, Heidelberg, pp. 391–422.
Braekers, K., Caris, A., Janssens, G.K., 2014. Exact and meta-heuristic approach for a
general heterogeneous Dial-A-Ride Problem with multiple depots. Transp. Res.
Part B 67, 166–186.
Caumond, A., Lacomme, P., Tchernev, N., 2008. A memetic algorithm for the job-
shop with time lags. Comput. Oper. Res. 35, 2331–2356.
Cordeau, J.F., Laporte, G., 2003. A tabu search heuristic for the static multi-vehicle
Dial-A-Ride Problem. Transp. Res. Part B 37, 579–594.
Cormen, T.H., Leiserson, C.L., Rivest, M.L., 1990. Introduction to algorithms. MIT
Press, Cambridge, MA.
Dongarra, J., 2014. Performance of Various Computers Using Standard Linear
Equations Software, (Linpack Benchmark Technical Report, CS-89-85). Uni-
versity of Tennessee, Computer Science Department, http://www.netlib.org/
benchmark/performance.pdf.
Dumas, Y., Desrosiers, J., Soumis, F., 1991. The pickup and delivery problem with
time windows. Eur. J. Oper. Res. 54, 7–22.
Firat, M., Woeginger, G.J., 2011. Analysis of the Dial-A-Ride Problem of Hunsaker
and Savelsbergh. Oper. Res. Lett. 39, 32–35.
Golden, B., Raghavan, S., Wasil, E., 2008. The Vehicle Routing Problem: Latest
Advances and New Challenges (Operations Research/Computer Science Inter-
faces), 43. Springer, US.
Lin, S., Kernighan, B.W., 1973. An effective heuristic algorithm for the traveling-
salesman problem. Oper. Res. 21 (2), 498–516.
Lourenço, H.R., Martin, O.C., Stützle, T., 2003. Iterated local search. In: Glover, F.,
Kochenberger, G. (Eds.), Handbook of Metaheuristics, 57. Springer, US New
York, pp. 320–353.
Madsen, O.B.G., Ravn, H.F., Rygaard, J.M., 1995. A heuristic algorithm for the Dial-A-
Ride Problem with time windows, multiple capacities, and multiple objectives.
Ann. Oper. Res. 60, 193–208.
Masson, R., Lehuédé, F., Péton, O., 2014. The Dial-A-Ride Problem with transfers.
Comput. Oper. Res. 41, 12–23.
Mester, D., Bräysy, O., 2007. Active-guided evolution strategies for large-scale
capacitated vehicle routing problems. Comput. Oper. Res. 34, 2964–2975.
Nagata, Y., Bräysy, O., 2009. Edge assembly-based memetic algorithm for the
capacitated vehicle routing problem. Networks 54 (4), 205–215.
 M. Chassaing et al. / Engineering Applications of Artificial Intelligence 48 (2016) 119–133
Parragh, S.N., Schmid, V., 2013. Hybrid column generation and large neighborhood
search for the Dial-A-Ride Problem. Comput. Oper. Res. 40 (1), 490–497.
Parragh, S.N., Doerner, K.F., Hartl, R.F., 2010. Variable neighborhood search for the
Dial-A-Ride Problem. Comput. Oper. Res. 37 (6), 1129–1138.
Potvin, J.Y., Rousseau, J.M., 1993. A parallel route building algorithm for the vehicle
routing and scheduling problem with time windows. Eur. J. Oper. Res. 66 (3),
331–340.
Prins, C., 2004. A simple and effective evolutionary algorithm for the vehicle
routing problem. Comput. Oper. Res. 31 (12), 1985–2002.
Prins, C., 2009. A GRASP evolutionary local search hybrid for the vehicle routing
problem. In: Pereira, F.B., Tavares, J. (Eds.), Bio-inspired Algorithms for the
Vehicle Routing Problem, Studies in Computational Intelligence, vol. 161.
Springer, Berlin, pp. 35–53 2009.
Psaraftis, H.N., 1980. A dynamic programming solution to the single vehicle many-
to-many immediate request Dial-A-Ride Problem. Transp. Sci. 14, 130–154.
Rekiek, B., Delchambre, A., Saleh, H.A., 2006. Handicapped person transportation
problem: an application of the grouping genetic algorithm. Eng. Appl. Artif.
Intel. 19, 511–520.
133
Ropke, S., Cordeau, J.-F., Laporte, G., 2007. Models and branch-and-cut algorithms
for pickup and delivery problems with time windows. Networks 49 (4),
258–272.
Roy, B., Sussmann, B., 1964. Les problèmes d'ordonnancement avec contraintes
disjonctives. SEMA, Paris, Note DS no. 9 bis.
Savelsbergh, M.W.P., 1992. The vehicle routing problem with time windows:
minimizing route duration. ORSA J. Comput. 4 (2), 146–154.
Toth, P., Vigo, D., 1996. Fast local search algorithms for the handicapped persons
transportation problem. In: Osman, I.H., Kelly, J.P. (Eds.), Meta-Heuristics:
Theory and Applications. Springer, US, Boston, pp. 677–690.
Vidal, T., Crainic, T.G., Gendreau, M., Prins, C., 2014. Implicit depot assignments and
rotations in vehicle routing heuristics. Eur. J. Oper. Res. 237 (1), 15–28.
Wolf, S., Merz, P., 2007. Evolutionary local search for the super-peer selection
problem and the p-hub median problem. Lect. Notes Comput. Sci. 4771, 1–15.