Gutenberg School of Management and Economics
& Research Unit “Interdisciplinary Public Policy”
Discussion Paper Series
Adaptive Large Neighborhood Search with a
Constant-Time Feasibility
Test for the Dial-a-Ride Problem
Timo Gschwind and Michael Drexl
December 22, 2016
Discussion paper number 1624
Johannes Gutenberg University Mainz
Gutenberg School of Management and Economics
Jakob-Welder-Weg 9
55128 Mainz
Germany
wiwi.uni-mainz.de
Contact Details:
Timo Gschwind
Chair of Logistics Management
Gutenberg School of Management and Economics
Johannes Gutenberg University Mainz
Jakob-Welder-Weg 9
55099 Mainz, Germany
[email protected]
Michael Drexl
Chair of Logistics Management
Gutenberg School of Management and Economics
Johannes Gutenberg Universität Mainz
Jakob-Welder-Weg 9
55128 Mainz, Germany
Faculty of Applied Natural Sciences and Industrial Engineering
Deggendorf Institute of Technology
94469 Deggendorf, Germany
[email protected]
All discussion papers can be downloaded from http://wiwi.uni-mainz.de/DP
Adaptive Large Neighborhood Search with a Constant-Time Feasibility
Test for the Dial-a-Ride Problem
Timo Gschwind∗,a , Michael Drexla,b
a Chair
of Logistics Management, Gutenberg School of Management and Economics, Johannes Gutenberg University,
D-55099 Mainz, Germany.
b Faculty of Applied Natural Sciences and Industrial Engineering, Deggendorf Institute of Technology, D-94469 Deggendorf,
Germany
Abstract
In the dial-a-ride problem (DARP), user-specified transport requests from origin to destination points have
to be served by a fleet of homogeneous vehicles. The problem variant we consider aims at finding a set of
minimum-cost routes satisfying constraints on vehicle capacity, time windows, maximum route duration, and
maximum user ride times. We propose an adaptive large neighborhood search (ALNS) for its solution. The
key novelty of the approach is an exact amortized constant-time algorithm for evaluating the feasibility of
request insertions in the repair steps of the ALNS. In addition, we use two optional improvement techniques:
a local-search based, intra-route improvement of routes of promising solutions using the Balas-Simonetti
neighborhood, and the solution of a set-partitioning model over a subset of all routes generated during the
search. With these techniques, the proposed algorithm outperforms the state-of-the-art methods in terms of
solution quality. New best solutions are found for several benchmark instances.
Key words: Dial-a-ride problem, Adaptive large neighborhood search, Feasibility testing
1. Introduction
The dial-a-ride problem (DARP) is concerned with the transport of persons from origin to destination
locations by a given vehicle fleet so as to minimize an objective while respecting a set of constraints related
to aspects of user inconvenience. Practical applications are widespread and occur, e.g., in door-to-door
transport of schoolchildren, patients, and elderly or disabled people as well as public transport services in
rural areas. There are static and dynamic versions of DARPs. In the static version, all transport requests are
known in advance. In the dynamic case, requests appear successively over time and must be accommodated
into a route plan that is already being executed. The present paper considers what is now commonly referred
to as the standard version of the DARP (introduced by Cordeau and Laporte, 2003): a static setting where
the objective is to minimize routing costs while satisfying constraints on vehicle capacity, time windows,
maximum route duration, and maximum user ride times.
The main contribution of the paper is an exact amortized constant-time algorithm for checking the
feasibility of a given route, i.e., using auxiliary data computed in a preprocessing step, the check itself
takes constant time and is independent of the number of customers in a route. This routine is embedded
in an adaptive large neighborhood search metaheuristic with two optional improvement techniques: a localsearch based, intra-route improvement of all routes of promising solutions by means of the Balas-Simonetti
neighborhood (Balas and Simonetti, 2001), and the solution of a set-partitioning problem over a subset
of all routes generated during the search. With these techniques, the proposed algorithm outperforms the
state-of-the-art methods in terms of solution quality, and new best solutions are found for several benchmark
instances.
The remainder of the paper is structured as follows. In the next section, a brief overview of recent
literature on DARPs is given. In Section 3, we formally describe the problem under study. Section 4 gives
details on the ALNS and the improvement techniques we use. Section 5 describes our feasibility checking
routine, Section 6 presents and discusses the results of the computational experiments performed with our
algorithm, and Section 7 concludes the paper with an outlook on promising avenues for future research.
∗ Corresponding
author.
Email addresses: [email protected] (Timo Gschwind), [email protected] (Michael Drexl)
Technical Report LM-2016-08
December 22, 2016
2. Related Work
Comprehensive surveys on the DARP literature are provided by Cordeau and Laporte (2007) and Doerner
and Salazar-González (2014). In the following, we concentrate on the more recent contributions, on important
problem extensions, and on work focusing on feasibility checks.
There are only few papers on exact approaches for the DARP: Cordeau (2006) and Ropke et al. (2007)
describe branch-and-cut algorithms, Ropke and Cordeau (2009) and Gschwind and Irnich (2015) present
branch-and-price-and-cut procedures. Qu and Bard (2015) study an extension of the DARP where vehicles
can be configured before service begins to handle different request types. They also apply branch-and-cutand-price. In general, the path-variable based approaches show superior performance. However, the largest
instances that have been solved to optimality have no more than 96 requests and 8 vehicles, and have tight
time windows and ride time constraints. Therefore, heuristics are needed to solve larger and less tightly
constrained instances in reasonable time.
Important contributions on heuristics for the DARP are Cordeau and Laporte (2003) (tabu search),
Jain and Van Hentenryck (2011) (large neighborhood search), Parragh et al. (2010) (variable neighborhood
search), Kirchler and Wolfler Calvo (2013) (granular tabu search), Parragh and Schmid (2013) (matheuristic
combining column generation and large neighborhood search), Ritzinger et al. (2014) (large neighborhood
search with dynamic-programming based recreate procedures), Masson et al. (2014) (large neighborhood
search), Braekers et al. (2014) (threshold accepting), Chassaing et al. (2016) (evolutionary local search).
As for feasibility testing of a given route, most of the above papers use or slightly adapt the eightstep evaluation scheme introduced by Cordeau and Laporte (2003), which is based on the forward time
slack concept introduced by Savelsbergh (1992). The scheme tries to find a feasible schedule by sequentially
minimizing violations of time windows, maximum route duration and maximum ride times. It has a worstcase running time complexity of O (r2 ) (r being the number of stops in the route).
Hunsaker and Savelsbergh (2002) propose a routine for checking the feasibility of a route in a DARP with
an additional upper bound on the waiting time. In three passes along the route, they compute and update
values for the arrival, departure, and waiting time at each vertex. The routine has linear time complexity,
but it is only a heuristic and does not guarantee to find a feasible schedule if one exists. Haugland and Ho
(2010) modify the Hunsaker and Savelsbergh (2002) heuristic and develop an exact procedure with O (r log r)
complexity. Tang et al. (2010) present an algorithm with a worst-case runtime complexity of O (r2 ). They
also try to gradually build up a feasible schedule directly on the network of the DARP instance. Firat
and Woeginger (2011) provide an O (r) check. Contrary to the aforementioned approaches, these authors
reformulate the scheduling problem as a system of difference constraints and reduce the problem to one of
determining whether or not a special digraph associated with such a system has a negative-weight cycle.
Through an appropriate formulation of the system, this test can be performed in linear time.
Chassaing et al. (2016) perform an empirical comparison of the feasibility-checking routines of Cordeau
and Laporte (2003) and Firat and Woeginger (2011). As mentioned, the former has a theoretical time
complexity quadratic in the number of stops in a route, the latter has a linear one. The computational
findings of Chassaing et al. (2016) confirm these theoretical results.
Gschwind (2015b) derives route feasibility checks for the synchronized pickup and delivery problem
(SPDP) introduced by Gschwind (2015a). The SPDP is a generalization of the DARP with maximum and
minimum ride time constraints. Gschwind (2015b) adapts the approaches of Tang et al. (2010) and Firat and
Woeginger (2011) to the SPDP. Computational results indicate that, despite the better worst-case runtime
complexity of the latter approach, the former shows a superior performance in the average case.
Parragh et al. (2009) and Molenbruch et al. (2017) present tailored feasibility checks for problems where
the objective function consists of or contains the minimization of the average or total user ride time. Parragh
et al. (2009) modify the checking procedure of Cordeau and Laporte (2003) by changing the computation
of the forward time slack so as to avoid an increase of ride times caused by a delay of the start of service at
destination vertices. The procedure described by Molenbruch et al. (2017) is initiated with a schedule where
total user ride time is at its lower bound. In five consecutive algorithmic steps, it is tried to reach a feasible
solution while avoiding, as far as possible, to increase the total user ride time.
Also Berbeglia et al. (2011) and Häeme and Hakula (2015) deal with feasibility testing in the DARP
context. However, these authors are concerned with determining whether or not a feasible solution for a
given problem instance exists. This is clearly a different focus. Berbeglia et al. (2011) apply constraint
programming, and Häeme and Hakula (2015) develop an approach based on dynamic programming. The
algorithms proposed by these authors are not directly applicable to the situation we consider.
Recently, several practically relevant generalizations of the DARP have been studied. These include, in
2
particular, multiple objectives (e.g., transport costs and user inconvenience), a heterogeneous fleet (e.g.,
vehicles with different start and end locations or different capacities), and customers with different transport requirements (e.g., specialized equipment for accommodating elderly or handicapped people). Good
overviews of the literature on generalized DARPs are given by Braekers et al. (2014) and Molenbruch et al.
(2017). Moreover, the option of passengers changing vehicles during their trip, very common in public transport, has been studied for the DARP (Masson et al., 2014; Schoenberger, 2016). Allowing such transfers
introduces intricate interdependencies between routes and requires their synchronization in space and time.
No constant-time feasibility check is known for this problem extension.
3. Problem Description
The DARP version under study here is defined on a complete directed graph G = (V, A) with node set
V and arc set A. The node set V = P ∪ D ∪ {0, 2n+1} comprises the pickup nodes P = {1, . . . , n} and
the delivery nodes D = {n+1, . . . , 2n} of n transport requests. Nodes 0 and 2n+1 denote the origin and
destination depot respectively. Each transport request i = 1, . . . , n has an associated pickup node i and an
associated delivery node i+n. For convenience, a request i is identified by its pickup node and we use the
set P also to refer to requests. A homogeneous fleet K of vehicles, each with a capacity of Q, is located at
the origin depot 0 to serve the transport requests. A maximum route duration L limits the time between
the start and the end of each vehicle route. Similarly, a maximum ride time Li limiting the time between
pickup and corresponding delivery is given for each request i ∈ P . With each node i ∈ V , a time window
[ai , bi ], a nonnegative service duration si , and a demand qi with qi = −qi+n are associated. Finally, a travel
time tij and a routing cost cij are associated with each arc (i, j) ∈ A. We assume that both routing costs
and travel times are nonnegative and satisfy the triangle inequality.
A feasible solution of the DARP serves all transport requests exactly once using at most |K| vehicle
routes. Each route has to start at the origin depot, end at the destination depot, and must not take longer
than L units of time. The service at each node i has to start within the time window [ai , bi ]. Waiting prior
to the service is allowed at any node and any time. Pickup node i and corresponding delivery node i+n of
each request have to be served on the same route and the pickup must precede the delivery. Moreover, the
service at the delivery node i+n must start at most Li units of time after the service at the pickup node
i has been completed. The capacity of the vehicles must not be exceeded at any time. The objective is to
minimize the total routing costs.
4. Adaptive Large Neighborhood Search
Adaptive large neighborhood search (ALNS) is one of the most successful metaheuristic approaches for
a broad range of routing problems, cf. the survey by Pisinger and Ropke (2010). It is based on the LNS
principle introduced by Shaw (1997). Basically, LNS works as follows. Given an incumbent solution, several
of its elements are iteratively removed and reinserted to create a new solution, which is accepted if it
improves on the best solution found so far or fulfils some other acceptance criterion. Ropke and Pisinger
(2006) extended the LNS scheme by adding different removal and reinsertion operators and an adaptive
operator selection scheme.
The ALNS we use closely follows their approach, but employs several additional removal procedures. We
adopt all removal and reinsertion operators described in their paper (random, worst and Shaw removal, basic
greedy, regret-2, -3, -4 and -M reinsertion), use a roulette wheel method with adaptive weight adjustment for
selecting the removal and reinsertion operators in each iteration, and apply a simulated annealing acceptance
criterion. The additional removal strategies built into our ALNS are as follows. An arc frequency history
removal heuristic, proposed by Masson et al. (2013), aims to remove requests that appear to be badly
positioned in the current solution with regard to the best known solutions. The heuristic keeps track of
the number of times each arc in the instance graph appears in one of the m best solutions found so far.
Whenever a solution enters (leaves) this elite set, the frequencies of the arcs in this solution are incremented
(decremented). In a removal step, for each request, the frequencies of the arcs over which its pickup and its
delivery vertex are reached and left in the current solution are summed up. The requests with the lowest
sums are removed, with a certain amount of randomness as proposed by Ropke and Pisinger (2006). A
zero-split removal heuristic, proposed by Parragh et al. (2010), removes sequences of requests between two
arcs where the vehicle is empty. Longer sequences are preferred. The removed requests are reinserted one
by one. An entire-route removal heuristic, as its name implies, removes one or more complete routes from
a solution. This is done in a random fashion. Entire-route removal is a special case of zero-split removal, as
3
a vehicle is always empty when leaving the depot and when returning to it. The worst and Shaw removal
heuristics are implemented in a static and a dynamic version. In the static versions, the removal criteria
are not updated after each removal of a single request, in the dynamic versions, they are. (The removal
criterion for worst removal is the difference in the cost of the current solution with and without a certain
request. Shaw removal uses a relatedness measure that takes into account, among other things, the points
in time when the pickup and the delivery vertex of a request are visited.) Our implementation also uses
an extended entire-route removal heuristic that, given a number q of requests to be removed, removes q/2
requests by a randomly selected removal heuristic other than entire-route removal, and removes at least q/2
further requests by means of entire-route removal.
After each remove-reinsert iteration, if the obtained solution is within 5 % of the best solution found
so far, each route of the new solution undergoes an optimization with the Balas-Simonetti neighborhood
(Balas and Simonetti, 2001). Given a route R = (v1 , . . . , vr ) and a positive integer k, this neighborhood
consists of all routes in which, for all i, j ∈ {1, . . . , r}, vertex vi precedes vertex vj whenever j ≥ i + k. The
authors propose a dynamic-programming algorithm that solves the problem of finding the best neighbor in
time linear in r, but exponential in k. To this end, a layered network is constructed with one layer of vertices
for each position in the route, so that there is a one-to-one correspondence between source-sink paths in
this network and routes that satisfy the required precedence constraints. The Balas-Simonetti neighborhood
was initially developed for the TSP and the TSP with time windows (TSPTW). However, with very minor
modifications that do not affect the complexity of the procedure, it can be applied to problems with other
precedence constraints as well as capacity restrictions. We use the dynamic-programming labeling algorithm
of Gschwind and Irnich (2015) to solve the resulting shortest-path problems.
At the end of the ALNS, we solve a set-covering problem. The column pool used consists of those routes
that were optimized with the Balas-Simonetti search or, when Balas-Simonetti is not applied, all routes
generated during the search process. As the number of routes in the pool can be quite large, we do not
necessarily solve the set-covering problem to optimality, but limit the running time to two minutes.
5. Feasibility of Request Insertions
The repair steps of the ALNS need to evaluate the insertion of single requests into given feasible routes.
A crucial aspect of such an evaluation is testing whether or not this insertion is feasible, i.e., if the resulting
route is feasible. In principle, this can be done using any of the route feasibility algorithms mentioned
in Section 2. However, during the ALNS, millions of insertions must be checked for feasibility, so that
the check should be as efficient as possible and preferably have constant time complexity. Typically, this
requires a specialized procedure for the evaluation of a request insertion into a given feasible route. Such O (1)
verification procedures for the insertion of single customers or customer requests are known for several classes
of routing problems (cf. Irnich, 2008; Vidal et al., 2014). Usually, these procedures require the use of some
auxiliary data that has to be recomputed each time one of the routes is modified. Since the preprocessing
steps are called much less frequently than the feasibility tests, an improvement of the efficiency of the
feasibility test typically overcompensates an increased effort for the computation of auxiliary data.
As mentioned, a feasible DARP route must satisfy constraints on pairing and precedence, vehicle capacity,
time windows, maximum route duration, and maximum ride times. Ensuring pairing and precedence of a
request insertion is straightforward. The verification whether an insertion is compatible with the capacity
constraint is independent of the temporal constraints and identical for the DARP and the pickup-and-delivery
problem with time windows (PDPTW). We omit a description here and refer to Vidal et al. (2014).
Checking whether or not a route R = (v1 , . . . , vr ) with v1 = 0 and vr = 2n+1 respects the temporal
constraints of the DARP is a nontrivial problem. The main difficulty is to deal with the trade-off between
serving all nodes early (promoting feasibility regarding time windows) and serving pickup nodes and the
origin depot late (promoting feasibility regarding maximum route duration and ride times). Formally, one
has to find a schedule T = (τ1 , . . . , τr ) of service times, i.e., points in time τi when the service at vi starts,
for all i = 1, . . . , r, satisfying
avi ≤ τi ≤ bvi ∀vi ∈ R,
τi + ti,i+1 ≤ τi+1 ∀vi ∈ R, i = r
τi + Lvi ≥ τi− ∀vi ∈ R ∩ P,
τ1 + L ≥ τr .
4
(1)
(2)
(3)
(4)
The notation i− (i+ ) is used to refer to the corresponding delivery (pickup) node of a request or node
i. (1), (3), and (4) are constraints on time windows, maximum ride times, and maximum route duration
respectively. Consistency of the service times along the route is ensured by constraints (2). The system (1)–
(4) is called the scheduling problem of the DARP. The set of feasible time schedules for route R is denoted
by TR . Note that the maximum route duration L can be seen as the maximum ride time L0 of a dummy
request 0 starting and ending at the origin and destination depots and, thus, be treated in the same fashion
as the other ride time constraints. We use this representation for the remainder of the paper and denote by
P0 = P ∪ {0} and D0 = D ∪ {2n+1} the sets of original requests/pickups and deliveries together with the
respective nodes of the dummy request.
Constant-Time Feasibility Testing for the PDPTW. Without the maximum ride times (3) for the requests
i ∈ P0 , the resulting scheduling problem (1)–(2) is straightforward to solve. It is the scheduling problem
of many variants of routing problems with time windows, such as the PDPTW. Traversing a route once
from origin to destination depot and serving each node as early as possible is an optimal strategy for this
problem. If this does not result in a feasible schedule, the route is infeasible. This is the key property that is
exploited in the constant-time feasibility test for request insertions in the PDPTW. Another main tool that
is used is the so-called Forward Time Slack (FTS) originally defined by Savelsbergh (1992) in the context
of the TSPTW. Given a feasible schedule T for route R, the FTS Fi at a node vi gives the maximum
amount of time by which the service time τi at vi can be delayed so that the resulting schedule is also
is always clear
feasible. For ease of notation, we omit the dependence of Fi on T as the base schedule
from
is
given
by
F
=
min
+
(b
−
τ
)
, where
w
the context.
For
the
scheduling
problem
(1)–(2),
F
i
i
i≤j≤r
i,j
v
j
j
wi,j = i<p≤j τp − (τp−1 + tp−1,p ) denotes the cumulative waiting time between nodes vi and vj . Note that
Fi depends on the service times τj with j ≥ i, but not on those τj with j < i.
Algorithm 1: Evaluate Feasibility of Request Insertion in PDPTW
Input: nodes vk , vl , request i
/* determine earliest possible service time at i+
1 τi+ = max{ai+ , τk + tvk ,i+ }
2 if τi+ > bi+ then return false
/* evaluate time shift at vk+1
+
3 δk+1 = τi+ + ti+ ,vk+1 − τk+1
4 if δk+1 > Fk+1 then return false
/* determine earliest possible service times at vl and i−
+
5 τl = τl + (δk+1 − wk+1,l )
6 τi− = max{ai− , τl + tvl ,i− }
7 if τi− > bi− then return false
/* evaluate time shift at vl+1
+
8 δl+1 = τi− + ti− ,vl+1 − τl+1
9 if δl+1 > Fl+1 then return false
10 return true
*/
*/
*/
*/
Algorithm 1 sketches the basic course of an O (1) feasibility test for the PDPTW. It evaluates the
insertion of a pickup node i+ after node vk and the corresponding delivery node i− after node vl into a given
route R. (If k = l, some very minor modifications are necessary; we omit these for brevity.) Based on an
as-early-as-possible schedule T = (τ1 , . . . , τr ) for route R, an adapted schedule T = (τ1 , . . . , τr ) for the new
route R = (v1 , . . . , vk , i+ , vk+1 , . . . , vl , i− , vl+1 , . . . , vr ) is implicitly constructed as follows: The pickup node
i+ is inserted with the earliest possible service time (Line 1). Its insertion generally increases the service
time at node vk+1 compared to τk+1 (Line 3). By means of the FTS Fk+1 it can be checked whether this
increase δk+1 still allows a feasible schedule for R (Line 4). Using δk+1 and wk+1,l , the earliest possible service
time τl at vl for the extended route R can be computed (Line 5). The impact of inserting delivery node i−
is then evaluated in the same fashion as for i+ (Lines 6–9). If the base schedule T , the FTS-values of all
nodes, and the cumulative waiting times between all pairs of nodes are known, Algorithm 1 clearly runs in
constant time for any vk , vl , and i. The computation of these numbers requires a runtime quadratic in r,
but can be done in a preprocessing step.
5
Li+ = 50
0
10
10
0
i
[0, 100]
40
10
+
j
[10, 30]
+
50
10
j
[40, 60]
−
[50, 70]
70
60
10
i
−
10
[60, 80]
2n+1
[0, 100]
Figure 1: Example of non-unique forward time slacks
Constant-Time Feasibility Testing for the DARP. Our O (1) feasibility test for request insertions in the
DARP follows the basic principle of Algorithm 1: Based on an as-early-as-feasible schedule T for the original
route R, it tries to implicitly construct a feasible schedule T for the extended route R . The additional
presence of maximum ride time constraints and the inherent trade-off between serving all nodes early and
serving pickup nodes late, however, raises additional issues compared to the PDPTW case. First, serving
all nodes as early as they can be reached is no longer an optimal strategy. Indeed, it may be be beneficial
to voluntarily wait and serve a pickup node i+ later than at the earliest possible time, to prevent waiting
at subsequent nodes and, hence, to decrease the ride time of the corresponding request i. It is therefore not
sufficient to consider only as-early-as-possible service times for both the base schedule T and the insertion
of the pickup node i+ . Second, when computing the maximum delay at a node vi that still allows a feasible
schedule, the ride times of all requests that are picked up before and delivered after vi have to be taken into
account. To cope with the latter, Cordeau and Laporte (2003) proposed the following adaptation of the FTS
for the DARP:
(5)
Fi = min wi,j + min(bvj − τj , Sij ) ,
i≤j≤r
where Sij is given by Lvj+ − τj − τj + if vj ∈ D0 , i > j + , and +∞ otherwise. In contrast to the PDPTW,
this definition of the FTS is not independent of the service times of nodes preceding vi (cf. Gschwind,
2015b). In fact, for a fixed service time τi , also for pickup nodes vj with j < i < j − , service times other
than the earliest possible ones must be considered, as different times may lead to different values Sij − and,
thus, to potentially different values for the FTS. Obviously, later service times τj for such pickup nodes vj
may lead to larger values Sij − and a larger Fi . Hence, given a service time τi serving all nodes vj with
j < i as late as possible is an optimal strategy to maximize Fi . Evidently, for the evaluation of insertions
into a route, the largest possible FTS-values, i.e., those resulting from an as-late-as-possible service at the
preceding nodes, must be taken into account. When considering the insertion of additional nodes into route
R, such an insertion before node vi may restrict the set of feasible service times at vj , j < i, and, thus,
change the FTS-values. Clearly, this effect also depends on the inserted node. Consider the example route
(0, i+ , j + , i− , j − , 2n+1) given in Figure 1. Time windows, travel times between all nodes, and the maximum
ride time of request i are depicted in the figure. The numbers above the nodes show an as-early-as-possible
schedule for the route. Fixing the service times at nodes j + , j − , and i− one at a time and determining
the respective FTS-values gives Fj + = Fj − = Fi− = 20 (implying a service time of 30 at node i+ ). When
inserting between nodes i+ and j + an additional node k with a nonbinding time window and travel times
ti+ ,k = tk,j + = 5, the earliest possible service times and the FTS-values for nodes j + , j − , and i− remain
unchanged. Assuming a time window of [10, 15] for the inserted node k, the earliest possible service times for
nodes j + , j − , and i− are still unchanged. The FTS-values of these nodes, however, are zero in the extended
route. As a result, there is not a single FTS for each node that can be computed in a preprocessing step and
that is valid for checking the feasibility of all request insertions at all positions.
The key idea to deal with these difficulties in a feasibility check is as follows. First, we sequentially try
to insert the pickup and delivery nodes of request i after nodes vk and vl at the earliest time they can
be reached (to facilitate time-window feasibility), checking whether or not the time shifts at the respective
successor nodes vk+1 and vl+1 are feasible using FTS-information Fk+1 and Fl+1 . Second, if this does not
result in a feasible schedule, the algorithm tries to decrease the ride times of request i or requests vj with
j < k < j − or j < l < j − by serving the respective pickup nodes later. This possibly leads to later service
times also at the succeeding nodes. Again, it must be checked whether or not the resulting time shifts at the
nodes vk+1 and vl+1 are feasible. To test the feasibility of these time shifts, given the service times at vk+1 and
vl+1 , the latest possible service times at all nodes preceding vk+1 and vl+1 are either computed explicitly or
considered implicitly in the respective FTS-information. To enable the latter, FTS-information depending
on the current latest possible service times at vk and vl is used.
To describe the feasibility test in more detail, it is convenient to introduce some additional notation
and results that are needed for the presentation of the algorithm. For each pair of nodes vi , vj ∈ R, i < j,
6
denote by Γij = i≤p<j tvp ,vp+1 the cumulative travel time between nodes vi and vj along route R. Instead
of the FTS Fi at a node vi ∈ R, i.e., the maximum amount of time by which the service time τi at a node
vi can be delayed such that a feasible schedule exists, we directly consider the latest feasible service time
τ i = maxT ∈TR τi . By definition of FTS, τi + Fi = τ i , so that considering Fi or τ i is equivalent. Furthermore,
we denote by τ i (tk ) = maxT ∈TR (tk ) τi with TR (tk ) = {T ∈ TR : τk ≤ tk } the latest feasible service time at
node vi such that node vk is served no later than tk . Similarly, let TR (tk , tl ) = {T ∈ TR : τk ≤ tk , τl ≤ tl }
and τ i (tk , tl ) = maxT ∈TR (tk ,tl ) τi . The following properties hold for the functions τ i , τ i (tk ), and τ i (tk , tl ):
, tmax
, tmin
, tmax
be the smallest and
Proposition 1. Let R = (v1 , . . . , vr ) be a feasible route and tmin
k
k
l
l
largest tk and tl such that TR (tk ) = ∅ and TR (tl ) = ∅. Then,
(i) T = (τ 1 , . . . , τ r ) ∈ TR and T (tk ) = (τ 1 (tk ), . . . , τ r (tk )) ∈ TR (tk ) for all vk ∈ R, tmin
≤ tk ≤ tmax
,
k
k
≤ tk ≤ tmax
, for certain constants h1i and h2i ,
(ii) τ i (tk ) = min{h1i , h2i + tk } for all vi , vk ∈ R, tmin
k
k
≤ tk ≤ tmax
, tmin
≤ tl ≤ tmax
.
(iii) τ i (tk , tl ) = min{τ i (tk ), τ i (tl )} for all vi , vk , vl ∈ R, tmin
k
k
l
l
Proof.
(i) T is feasible if and only if it satisfies constraints (1)–(4). By definition of τ i , there exists for each
vi ∈ R a feasible schedule T i = (τ1i , . . . , τ i , . . . , τri ) with τji ≤ τ j for all j = i. It follows immediately
i
i
that T satisfies constraints (1). Using τ i + tvi ,vi+1 ≤ τi+1
and τi+1
≤ τ i+1 , it follows that T satisfies
i−
i−
constraints (2). Similarly, τi + Lvi ≥ τ i− and τ i ≥ τi imply that constraints (3) and, by the same
argument, also constraint (4) hold for T . T (tk ) ∈ TR (tk ) can be shown in the same fashion.
(ii) For k = r, the result is included in Lemma 2 of Gschwind (2015a). The generalization of that proof to
the case k = r is obvious.
(iii) From TR (tk , tl ) ⊆ TR (tk ) and TR (tk , tl ) ⊆ TR (tl ), it follows immediately that τ i (tk , tl ) ≤ τ i (tk ) and
τ i (tk , tl ) ≤ τ i (tl ). Consequently, τ i (tk , tl ) ≤ min{τ i (tk ), τ i (tl )} for all vi , vk , vl ∈ R, tmin
≤ tk ≤
k
min
max
min
,
t
≤
t
≤
t
.
To
show
that
also
τ
(t
,
t
)
≥
min{τ
(t
),
τ
(t
)}
holds,
let
τ
(t
tmax
i
k
l
i
k
i
l
k , tl ) =
l
i
k
l
l
min{τ i (tk ), τ i (tl )} and consider the schedule T min (tk , tl ) = (τ1min (tk , tl ), . . . , τrmin (tk , tl )). It is clear
that τkmin (tk , tl ) ≤ tk and τlmin (tk , tl ) ≤ tl hold and that T min (tk , tl ) fulfills (1). Moreover, by definition
of τ i (tk ) and τ i (tl ), there exist for each vi ∈ R feasible schedules T i,k = (τ1i,k (tk ), . . . , τ i (tk ), . . . , τri,k (tk ))
with τji,k ≤ τ j (tk ) and T i,l = (τ1i,l (tl ), . . . , τ i (tl ), . . . , τri,l (tl )) with τji,l ≤ τ j (tl ) for all j = i. Comi,k
i,k
i,l
bining τ i (tk ) + tvi ,vi+1 ≤ τi+1
(tk ) and τi+1
(tk ) ≤ τ i+1 (tk ) with τ i (tl ) + tvi ,vi+1 ≤ τi+1
(tl ) and
i,l
min
(tk , tl ) satisfies constraints (2). Similar arguments to those
τi+1 (tl ) ≤ τ i+1 (tl ), it follows that T
used in the proof of (i) can be applied to show that T min (tk , tl ) respects constraints(3) and (4),
too. Consequently, T min (tk , tl ) ∈ TR (tk , tl ), and by definition of τ i (tk , tl ), we have that τ i (tk , tl ) ≥
τimin (tk , tl ) = min{τ i (tk ), τ i (tl )}. This completes the proof.
We split the feasibility test of inserting a request i into two parts. The first is the evaluation of the
insertion of the pickup node i+ after vk . The second is the evaluation of the insertion of the delivery node i−
after vl . Clearly, if i+ cannot be feasibly inserted at a specific position, neither position for the insertion
of the delivery node i− results in a feasible insertion of the request. Moreover, the insertion of the pickup
node i+ provides some information that can be reused for the evaluation of the insertion of the delivery
node i− at any considered position.
Algorithm 2 details the insertion of a pickup node i+ after node vk . It first tries to insert i+ as early
as it can be reached (Lines 1 and 2) and determines the resulting new earliest service time at the successor
, the service times at nodes i+ and vk are increased one after the other
node vk+1 (Line 3). Fixing time τk+1
by as much as possible (Lines 4 and 5), i.e., their latest feasible starts of service are computed. Finally, the
time shift at node k+1 is tested for feasibility using the bound τ k+1 (τk ) (Line 6). Note again that by means
of τ k+1 (τk ), it is implicitly considered that all nodes preceding vk are served as late as possible given service
at vk+1 . Note further that if
time τk , which is the latest possible service time at vk given service time τk+1
the test in Line 6 fails, there is no possibility to repair this defect, and the insertion of i+ between vk and
vk+1 is infeasible: the value of the bound τ k+1 (τk ) can only be increased by increasing τk . However, if there
is some waiting time between vk and vk+1 , then either the service at vk or i+ is already restricted (because
in Lines 4 and 5), so that delaying it is not feasible. If there is no waiting
of their maximization given τk+1
, so that the condition in
time between vk and vk+1 , then an increase of τk leads to the same increase of τk+1
Line 6 is still violated.
7
Algorithm 2: Evaluate Insertion of Pickup
Input: node vk , request i
/* determine earliest possible service time at i+
1 τi+ = max{ai+ , τk + tvk ,i+ }
2 if τi+ > bi+ then return false
/* determine earliest possible τk+1
3 τk+1 = max{τk+1 , τi+ + ti+ ,vk+1 }
/* maximize τk and τi+ for earliest possible service time at vk+1
4 τi+ = min{bi+ , τk+1 − ti+ ,vk+1 }
5 τk = min{τ k , τi+ − tvk ,i+ }
/* evaluate time shift at vk+1
6 if τk+1 > τ k+1 (τk ) then return false
7 return true
Output: service times τk , τi+ , τk+1
*/
*/
*/
*/
Algorithm 3 describes the insertion of a delivery node i− after node vl . It uses the information about the
provided by the feasibility check for the insertion of the corresponding
earliest service times τk , τi+ , and τk+1
+
and Γk+1,l , the new earliest start of
pickup node i after node vk in Algorithm 2. First, by means of τk+1
−
service τl at vl is computed (Line 1). Then, delivery node i is inserted as early as it can be reached if
feasible (Lines 2 and 3), and the new earliest service time at node vl+1 is determined (Line 4). If there is
waiting time before node i− , the service time τl at vl has to be maximized to obtain its latest feasible start
of service given time τi− (Line 5). Note that τl is also restricted by the ride times of requests that are picked
up prior to vl , which is ensured by the bound τ l (τk ). Note further that it is not necessary to increase the
service time at i− . This can be seen as follows. If there is no waiting time between nodes i− and vl+1 , then
. In the case of positive waiting time between i− and vl+1 , the service
τi− is already maximal given time τl+1
time at node vl+1 does not change compared to the service time τl+1 in the base schedule for R. Such a delay
of zero is clearly feasible, i.e., τ l+1 (τk , τl ) ≥ τl+1 for any feasible τk , τl .
Given times τk and τl , the time shift at node vl+1 is then evaluated (Lines 6 and 7). A delay at vl+1 that
seems to be too large, however, does not yet imply that the insertion is infeasible. In fact, it may be possible
to repair this defect. Recall that up to now the pickup node i+ has been inserted such that the succeeding
node vk+1 is served as early as it can be feasibly reached, thereby also restricting the possible service times
at pickup nodes preceding vk+1 . Allowing a later service time at vk+1 may reduce the ride times of requests
that are picked up before and delivered after vk+1 , which might in turn allow a feasible schedule with service
. Formally, this means trying to increase the bound τ l+1 (τk , τl ) on the service time
at node vl+1 at time τl+1
by increasing τk or τl while keeping τl+1
constant. Note first that it is impossible to restore feasibility by
τl+1
delaying only τl . This can be seen by distinguishing two cases. If there is waiting time between nodes vl and
i− , then τl is constrained by τ l (τk ) and can only be increased if τk is also increased. If there is no waiting
by the same
time before node i− , then delaying the service at node vl leads to an increase of τi− and τl+1
amount (note that ∆l+1 > 0 implies zero waiting time between nodes i− and vl+1 ) and, hence, the augmented
time shift at vl+1 is again infeasible. Therefore, the algorithm always needs to increase the service time at vk
in order to restore feasibility with respect to the time shift at vl+1 . Moreover, a repair can only be successful
if there is enough waiting time wk+1,i− between nodes vk+1 and i− on the route, as delaying the service time
τk at vk by ∆l+1 increases the bound τ l+1 (τk , τl ) by at most ∆l+1 , and if wk+1,i− is smaller than ∆l+1 , it also
, implying that a feasible schedule cannot exist.
increases the service time τl+1
The repair step is detailed in Lines 7–14. It first checks whether the repair can be successful, i.e., if the
service times at vk and i+ can be feasibly delayed by ∆l+1 and if there is enough waiting time (Line 8).
Then, the service times at vk , i+ , and vk+1 are increased (Lines 9–11) and the new time shift at vk+1 is
evaluated (Line 12). Note that after Line 8, there cannot be any waiting time between nodes vk , i+ , and
vk+1 . This is because otherwise, it would not be possible to increase the service times at vk or i+ , as they are
due to their maximization within the insertion of the pickup node i+
at their maximal value given time τk+1
(Lines 4 and 5 of Algorithm 2). Finally, the new maximum service time τl given the increased value τ l (τk )
is determined (Line 13), and it is checked whether the bound τ l+1 (τk , τl ) could be sufficiently improved to
allow a feasible insertion (Line 14).
So far, Algorithm 3 has ensured that the current implicitly built schedule T for the extended route R
respects the time windows (1) of all nodes Vj ∈ R , the consistency constraints (2) of the service times, and
8
the maximum ride times of requests vj ∈ P0 ∪ R. It remains to check whether the insertion is feasible also
with respect to the maximum ride time constraint of the inserted request i. If the current service times τi+
and τi− violate the maximum ride time by ∆i > 0, a repair procedure (Lines 16–21) similar to the one for
the time shift at vl+1 as described above tries to decrease the ride time of i by serving i+ later (i− is already
served as early as possible). A prerequisite is that the service at i+ can be postponed by ∆i units of time
and that there is sufficient waiting time between nodes vk+1 and i− (Line 17). The algorithm then increases
accordingly (Lines 18 and 19). Recall that there cannot be any waiting time
the service times τi− and τk+1
at node vk+1 . Finally, τk is maximized given the new service time at i− (Line 20) and the new start of service
at node vk+1 has to be checked for feasibility using the bound τ k+1 (τk ).
τk+1
Algorithm 3: Evaluate Insertion of Delivery
Input: nodes vk , vl , request i, service times τk , τi+ , τk+1
−
/* determine earliest service times at vl , i , and vl+1
1 τl = max{τl , τk+1 + Γk+1,l }
2 τi− = max{ai− , τl + tl,i− }
3 if τi− > bi− then return false
4 τl+1 = max{τl+1 , τi− + ti− ,vl+1 }
/* maximize τl for earliest possible service time at i− given τk at k
5 τl = min{τ l (τk ), τi− − tvl ,i− }
/* evaluate time shift at l+1 and try to increase τ l+1 (·) if necessary
6 ∆l+1 = τl+1 − τ l+1 (τk , τl )
7 if ∆l+1 > 0 then
8
if τk + ∆l+1 > τ k or τi+ + ∆l+1 > bi+ or ∆l+1 > wk+1,i− then return false
9
τk + = ∆l+1
τi+ + = ∆l+1
10
τk+1
+ = ∆l+1
11
/* evaluate new time shift at τk+1
12
if τk+1
> τ k+1 (τk ) then return false
/* maximize τl given new service time τk at k
13
τl = min{τ l (τk ), τi− − tl,i− }
/* evaluate time shift at τl+1
14
if τl+1 > τ l+1 (τk , τl ) then return false
21
/* evaluate ride time of request i and try to decrease it if necessary
∆i = τi− − (τi+ + Li )
if ∆i > 0 then
if τi+ + ∆i > bi+ or ∆i > wk+1,i− then return false
τi+ + = ∆i
τk+1
+ = ∆i
/* maximize τk given new service time τi+ at i+
τk = min{τ k , τi+ − tk,i+ }
/* evaluate new time shift at τk+1
if τk+1 > τ k+1 (τk ) then return false
22
return true
15
16
17
18
19
20
*/
*/
*/
*/
*/
*/
*/
*/
*/
Note that there are two special cases for the insertion positions that require slightly different handling
compared to the general procedure. The first is the insertion of pickup node i+ and delivery node i− in
direct succession, i.e., k = l. The second is the insertion of i+ and i− with only one node between them,
i.e., k + 1 = l. In the former case, the feasibility check is much simpler and the entire insertion can be
checked similar to the insertion of the pickup node in the general case detailed in Algorithm 2. The only
additional step is between Lines 2 and 3, where the insertion of the delivery node i− is performed computing
its service time as τi− = max{ai− , τi+ + ti+ ,i− }. Note that in this case the maximum ride time constraint
of request i is always respected if an appropriate time-window tightening in the preprocessing is performed.
Then, in Lines 3–5, ‘i+ ’ must be replaced with ‘i− ’. Moreover, as in the general case, it is not necessary to
. This follows from the argument given in the description
maximize the service times at i− given time τk+1
of Algorithm 3. In the second special case (k +1 = l), the insertion of the pickup node i+ is performed as
9
described in Algorithm 2. For the insertion of the delivery node i− , the following slight modifications have to
be made in Algorithm 3: Line 1 is obsolete, as the service time at node vk+1 = vl is already known from the
insertion of the pickup node. In Line 5 of the algorithm, the service time τl is increased. This may introduce
some waiting time between nodes i+ and vk+1 . Consequently, in Lines 8 and 17, the value wi+ ,i− needs to be
considered instead of wk+1,i− (recall that in the general case k+1 > l, it is ensured that there is no waiting
time between nodes i+ and k+1 at that point of the feasibility test). Furthermore, Lines 11 and 19 change
= max{τk+1
, τi+ + ti+ ,vk+1 }.
to τk+1
We now show that the entire feasibility check runs in O (1). Note first that all computations of Algorithms 2 and 3, i.e., service time updates and comparisons, can be performed in constant time provided that
all values used within these computations can be retrieved in constant time. Evidently, all input data, i.e.,
time-window borders a· and b· , travel times t·,· , and maximum ride times L· , are available in constant time.
The service times τi , i ∈ R, of the base schedule T and the cumulative travel times Γij between all pairs
of nodes vi , vj ∈ R, i < j, are computed in a preprocessing step. The latter also allow the constant-time
computation of the waiting times between all pairs of nodes vi , vj ∈ R , i < j, in the extended schedule
using the formula wij = τj − τi − Γij . Finally, the preprocessing ensures that the bounds τ i (tk ) and τ i (tk , tl )
can be retrieved in constant time for any vi , vk , vl ∈ R and any feasible tk and tl . As a result, checking the
feasibility of request insertions for the DARP can be done in O (1) time.
The computations and the computational effort of the preprocessing step are as follows. The determination of the cumulative travel times Γij between all pairs of nodes vi , vj ∈ R, i < j, in O (r2 ) is straightforward.
A feasible as-early-as-possible base schedule T = (τ1 , . . . , τr ) for route R can be computed using the algorithm
of Tang et al. (2010), which requires O (r2 ) computation time. Because of Proposition 1(ii), it is sufficient to
store the two values τ i (τk ) and τ i (τ k ) to provide in constant time the values of the bounds/functions τ i (tk )
for any vi , vk ∈ R, tk ≥ τk , via the expression τ i (tk ) = min{τ i (τk ) + (tk − τk ), τ i (τ k )}. Proposition 1(iii)
guarantees that also the values τ i (tk , tl ) with vi , vk , vl ∈ R, tk ≥ τk , tl ≥ τl , are then available in constant
time. For the computation of τ i (τk ) and τ i (τ k ), note first that τ i = τ i (τ k ) holds for all vi , vk ∈ R. Moreover,
the schedule T = (τ 1 , . . . , τ r ) where all nodes are served at their latest feasible time is feasible (Proposition 1(i)). This schedule can be computed with quadratic time complexity by using a modified version of
the algorithm of Tang et al. (2010) in which all passes over the route are traversed in opposite direction,
so that the algorithm provides an as-late-as-possible instead of an as-early-as-possible schedule. The values
τ i (τk ) are determined in an analogous fashion. When fixing the service time at node vk to τk , the schedule
T (τk ) = (τ 1 (τk ), . . . , τ r (τk )) is feasible according to Proposition 1(i). Again, the modified algorithm of Tang
et al. (2010) can be used to compute the values τ i (τk ), vi ∈ R, in quadratic time. As this has to be done for
each node vk ∈ R, the entire preprocessing requires O (r3 ) computation time. Theorem 1 summarizes the
main result of this section.
Theorem 1. For the DARP, the feasibility of an insertion of a request i into a given feasible route R =
(v1 , . . . , vr ) can be checked in constant time. The computational effort for preparing the necessary auxiliary
data in a preprocessing step is O (r3 ).
6. Computational results
The algorithm described in this paper was implemented in C++ and compiled with Visual Studio 2013
on Win 7, 64 Bit. The parameters used in the ALNS are detailed in the Appendix. IBM Ilog Cplex 12.6.2
was used for solving the set-covering problems. Here, we changed only two default settings: Cplex was run
in single-thread mode, and the MIP emphasis switch was set to emphasize feasibility over optimality. All
experiments were performed on a computer with an Intel Core i7-5930K CPU clocked at 3.50 GHz and with
64 GB main memory.
6.1. Instances
There are two standard sets of DARP benchmark instances commonly used in the literature. The first
one was proposed by Cordeau and Laporte (2003) and is referred to as the pr set. It comprises 20 instances
with up to 144 requests and 13 vehicles. The second set encompasses 42 instances in two groups (a and b)
with at most 96 requests and 8 vehicles and was created by Ropke et al. (2007), enlarging the set introduced
by Cordeau (2006). The latter instances, due to their limited size and their tight time windows and ride
time constraints, can all be solved to optimality in short time: With a branch-and-price-and-cut algorithm
by Gschwind and Irnich (2015), the average computation time is below 30 seconds on a desktop computer.
This is faster than any of the heuristics described in the literature (including ours), so these instances are
10
of limited interest for the evaluation of heuristic procedures. For the former instances, which are less tightly
constrained, no optimal solutions are known.
6.2. Analysis of Results
In this section, we first discuss how the time consumption of our constant-time feasibility check compares
empirically to that of the classical eight-step procedure by Cordeau and Laporte (2003) used by most
approaches from the literature. Then, we analyze the impact of different setups of our ALNS algorithm on
solution quality and running time. Finally, we compare the ALNS to state-of-the-art DARP heuristics from
the literature.
Empirical evaluation of the constant-time feasibility check. To evaluate our procedure empirically, we performed five runs over all benchmark instances with the pure ALNS (25,000 iterations, no Balas-Simonetti,
no set-covering), using (i) the constant-time test, (ii) the classical eight-step procedure by Cordeau and
Laporte (2003) (which has quadratic worst-case complexity), and (iii) an improved version of the latter test.
In this improved version, a constant-time PDPTW check (cf. again Vidal et al., 2014) that disregards the
ride time constraints is performed first. If this check returns “infeasible”, the route is obviously infeasible
also for the DARP; otherwise, the Cordeau-Laporte procedure is called. Compared to the standard test, our
algorithm showed speedup factors ranging between 5 and 72, with an average of 32. Relative to the improved
Cordeau-Laporte test, the speedup factors were still between 1.5 and 12, with an average of 3.8. In general,
the speedup factors increased with increasing instance size. Hence, the empirical evaluation confirmed the
theoretical superiority of our approach.
Impact of different configurations of the presented ALNS. We experimented with the following parameters:
number of ALNS iterations (25, 50, and 75,000); Balas-Simonetti local search (none, k ∈ {1, . . . , 6}); solution
of set-covering problem at the end (yes/no; time limit of 120 seconds). We chose a full factorial design for
the experiments and evaluated all benchmark instances for all 42 combinations of these parameters. The
effects of the different configurations on the pr instances are visualized in Figure 2. Detailed tables can be
found in the Appendix.
25,
25,
50,
50,
75,
75,
1,000
pure
SC
pure
SC
pure
SC
25,
25,
50,
50,
75,
75,
1.2
1
% Gap
Computation time in seconds
1,500
pure
SC
pure
SC
pure
SC
0.8
500
0.6
0
0.4
0
1
2
3
4
5
6
0
Balas-Simonetti k
1
2
3
4
5
6
Balas-Simonetti k
Figure 2: Computation times (left) and average relative gaps to BKS (right) for different algorithm configurations
As can be seen from Figure 2 (left), computation times increase linearly with increasing number of ALNS
iterations and exponentially with growing Balas-Simonetti k value. Solving the set-covering problem had
almost no effect, as the time limit was not reached in most cases. In Figure 2 (right), it can be seen that
increasing the Balas-Simonetti parameter tends to reduce the average gap. Moreover, irrespective of the
number of iterations and the Balas-Simonetti parameter, solving a set-covering problem at the end pays off
and always reduces the average gaps considerably. It can also be seen, however, that in several cases the gap
increases with increasing k value. We attribute this to the lower diversification potential of larger k values:
the larger k, the more often single routes are optimal for the requests they contain. Therefore, the input to
the next ALNS iteration after a Balas-Simonetti local search is more likely to be the same as in a preceding
iteration. Using an elbow criterion, the best trade-off between computation time and solution quality is
11
Braekers et al. (TA)
Instance
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
Chassaing et al. (ELS)
(50,no BS,no SC)
(75,k=3,SC)
BKS
Best
Avg
Time
Best
Avg
Time
Best
Avg
Time
Best
Avg
Time
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
190.02
301.34
532.10
577.16
629.80
797.78
292.23
490.94
662.64
853.98
164.46
295.69
488.61
534.99
581.46
743.56
249.33
461.77
598.23
795.08
0.81%
190.02
301.34
533.54
580.52
632.06
800.68
292.23
491.00
666.65
860.83
164.46
296.06
490.03
540.99
584.33
747.19
249.33
462.38
600.63
801.89
1.16%
16.6
42.0
48.8
74.6
89.2
107.0
22.6
48.6
72.2
114.4
23.8
51.4
76.2
117.0
155.2
180.6
34.0
81.0
146.4
162.8
83.2
190.02
301.34
532.43
570.54
630.82
792.80
291.71
491.60
672.86
857.36
164.46
295.66
489.00
531.08
578.44
731.25
248.21
461.21
595.39
796.60
0.64%
190.02
301.34
533.86
574.47
637.59
796.10
292.96
493.16
681.35
860.68
164.46
295.72
490.70
531.98
580.23
736.59
248.21
462.40
597.53
803.99
1.04%
15.0
75.0
138.0
442.2
724.2
1315.2
28.2
160.8
675.0
1279.8
16.8
82.2
222.0
612.0
1195.8
1939.2
34.8
259.2
745.8
1887.0
592.4
190.02
301.34
532.00
570.25
631.00
791.78
291.71
490.47
660.83
854.39
164.46
295.96
486.62
533.04
578.65
734.45
248.21
461.39
598.12
788.61
0.50%
190.02
301.34
532.40
574.11
634.38
794.92
291.71
492.91
666.42
861.75
164.46
296.27
488.29
536.62
582.26
740.49
248.21
463.54
599.78
791.01
0.88%
8.4
16.9
29.5
51.7
76.3
105.4
10.5
31.0
60.4
102.6
9.6
19.1
34.7
59.0
98.0
131.2
11.6
37.1
73.5
127.5
54.7
190.02
301.34
532.00
570.25
628.59
789.36
291.71
489.83
659.69
853.07
164.46
295.66
484.83
531.19
576.70
731.50
248.21
461.48
593.83
787.14
0.32%
190.02
301.34
532.01
570.61
630.99
790.44
291.71
491.13
660.13
857.18
164.46
296.22
484.83
531.92
578.17
736.08
248.21
461.67
596.77
789.83
0.50%
15.1
41.1
62.1
138.7
267.4
397.5
19.7
74.1
151.7
389.2
17.7
48.1
101.3
204.2
491.6
692.6
22.8
103.0
361.4
591.6
209.5
BKS: Best known solution; new BKSs found during our experiments are marked in bold
Best: best solution over five runs; BKSs found or confirmed by an algorithm are marked in bold
Avg: average solution over five runs; Time: CPU times in seconds for one run (unscaled)
Last row: average gaps to BKSs for Best and Avg columns; average CPU times over five runs for Time columns
Table 1: Aggregated results for pr instances
obtained for k = 3: computation times start to rise sharply for larger values, while the improvements in
solution quality are minor.
Performance of the ALNS compared to the state-of-the-art. Overall, the best-performing DARP heuristics
we are aware of are the threshold accepting procedure of Braekers et al. (2014) and the evolutionary local
search by Chassaing et al. (2016). We therefore compare our ALNS with these two approaches. Because of
the short running times all three approaches need for solving the benchmark instances, we do not attempt to
scale the computation times reported in the different papers. Anyway, no CPU benchmark data are available
for the system Braekers et al. (2014) used.
Over five runs on the less interesting instance sets a and b, the Braekers et al. (2014) algorithm finds
40 out of 42 optimal solutions, and the average gap over all runs is 0.01 %. Chassaing et al. (2016) find
33 optimal solutions, and the average gap is 0.06 %. Our heuristic has a comparable solution quality: with
our best configuration (75,k=3,SC) (75,000 ALNS iterations with Balas-Simonetti k = 3 and set-covering),
we find 37 optimal solutions, and the average gap is 0.05 %.
On the harder instance set pr, our heuristic performs even better. During all experiments performed
while writing this paper, we discovered new best known solutions (BKSs) for eight of these 20 instances
and confirmed the BKSs for the remaining twelve. As can be seen in Table 1, already the pure ALNS with
50,000 iterations clearly outperforms the state-of-the art with respect to solution quality: the average gaps
are better, and it is able to reproduce more best known solutions (7 compared to 3 and 6). The (75,k=3,SC)
configuration further improves on these results, with average gaps at least halved and nine BKSs confirmed.
7. Conclusion
In this paper, we have described a constant-time procedure for checking the feasibility of a given route of
the standard dial-a-ride problem, where a set of minimum-cost routes satisfying constraints on pairing and
precedence, vehicle capacity, time windows, maximum route duration, and maximum user ride time is sought.
Computational tests comparing the constant-time check with the classical eight-step procedure by Cordeau
and Laporte (2003) used by most approaches from the literature empirically confirm the theoretical superiority of our approach, which provides an average speedup factor of 3.8. We have embedded the procedure
12
into an adaptive large neighborhood search metaheuristic and used two optional improvement techniques
based on local search with the Balas-Simonetti neighborhood and on the solution of a set-partitioning model
containing a subset of the routes generated during the search process. The method is competitive with
state-of-the-art DARP heuristics regarding solution quality and running time. On the classical benchmark
set of Cordeau and Laporte (2003), it clearly outperforms all previous solution approaches.
In future work, we intend to generalize our feasibility check to extensions of the DARP. In particular,
the DARP with transfers as described by Masson et al. (2014) and the synchronized pickup-and-delivery
problem (SPDP) introduced by Gschwind (2015a) are of interest in this respect.
Acknowledgement
This research was partially funded by the Deutsche Forschungsgemeinschaft (DFG) under grant no. IR
122/7-1.
References
Balas, E. and Simonetti, N. (2001). Linear time dynamic-programming algorithms for new classes of restricted TSPs: A
computational study. INFORMS Journal on Computing, 13(1), 56–75.
Berbeglia, G., Pesant, G., and Rousseau, L.-M. (2011). Checking the feasibility of dial-a-ride instances using constraint
programming. Transportation Science, 45(3), 399–412.
Braekers, K., Caris, A., and Janssens, G. K. (2014). Exact and meta-heuristic approach for a general heterogeneous dial-a-ride
problem with multiple depots. Transportation Research Part B, 67, 166–186.
Chassaing, M., Duhamel, C., and Lacomme, P. (2016). An ELS-based approach with dynamic probabilities management in
local search for the dial-a-ride problem. Engineering Applications of Artificial Intelligence, 48, 119–133.
Cordeau, J.-F. (2006). A branch-and-cut algorithm for the dial-a-ride problem. Operations Research, 54, 573–586.
Cordeau, J.-F. and Laporte, G. (2003). A tabu search heuristic for the static multi-vehicle dial-a-ride problem. Transportation
Research Part B, 37, 579–594.
Cordeau, J.-F. and Laporte, G. (2007). The dial-a-ride problem: Models and algorithms. Annals of Operations Research,
153(1), 29–46.
Doerner, K. and Salazar-González, J. (2014). Pickup-and-delivery problems for people transportation. In D. Vigo and P. Toth,
editors, Vehicle Routing, chapter 7, pages 193–212. Society for Industrial and Applied Mathematics, Philadelphia.
Firat, M. and Woeginger, G. J. (2011). Analysis of the dial-a-ride problem of Hunsaker and Savelsbergh. Operations Research
Letters, 39(1), 32–35.
Gschwind, T. (2015a). A comparison of column-generation approaches to the synchronized pickup and delivery problem.
European Journal of Operational Research, 247(1), 60–71.
Gschwind, T. (2015b). Route feasibility testing and forward time slack for the synchronized pickup and delivery problem.
Technical Report LM-2015-01, Chair of Logistics Management, Gutenberg School of Management and Economics, Johannes
Gutenberg University Mainz, Mainz, Germany.
Gschwind, T. and Irnich, S. (2015). Effective handling of dynamic time windows and its application to solving the dial-a-ride
problem. Transportation Science, 49(2), 335–354.
Häeme, L. and Hakula, H. (2015). A maximum cluster algorithm for checking the feasibility of dial-a-ride instances. Transportation Science, 49(2), 295–310.
Haugland, D. and Ho, S. (2010). Feasibility testing for dial-a-ride problems. In B. Chen, editor, Algorithmic Aspects in Information and Management, volume 6124 of Lecture Notes in Computer Science, pages 170–179. Springer, Berlin, Heidelberg.
Hunsaker, B. and Savelsbergh, M. (2002). Efficient feasibility testing for dial-a-ride problems. Operations Research Letters,
30, 169–173.
Irnich, S. (2008). A unified modeling and solution framework for vehicle routing and local search-based metaheuristics. INFORMS Journal on Computing, 20(2), 270–287.
Jain, S. and Van Hentenryck, P. (2011). Large neighborhood search for dial-a-ride problems. In Principles and Practice of
Constraint Programming – CP 2011, pages 400–413. Springer.
Kirchler, D. and Wolfler Calvo, R. (2013). A granular tabu search algorithm for the dial-a-ride problem. Transportation
Research Part B, 56, 120–135.
Masson, R., Lehuédé, F., and Péton, O. (2013). An adaptive large neighborhood search for the pickup and delivery problem
with transfers. Transportation Science, 47(3), 344–355.
Masson, R., Lehuédé, F., and Péton, O. (2014). The dial-a-ride problem with transfers. Computers & Operations Research,
41, 12–23.
Molenbruch, Y., Braekers, C., Caris, A., and Vanden Berghe, G. (2017). Multi-directional local search for a bi-objective
dial-a-ride problem in patient transportation. Computers & Operations Research, 77, 58–71.
Parragh, S. and Schmid, V. (2013). Hybrid column generation and large neighborhood search for the dial-a-ride problem.
Computers & Operations Research, 40(1), 490–497.
Parragh, S., Doerner, K., Hartl, R., and Gandibleux, X. (2009). A heuristic two-phase solution approach for the multi-objective
dial-a-ride problem. Networks, 54(4), 227–242.
Parragh, S., Doerner, K., and Hartl, R. (2010). Variable neighborhood search for the dial-a-ride problem. Computers &
Operations Research, 37(6), 1129–1138.
Pisinger, D. and Ropke, S. (2010). Large neighborhood search. In M. Gendreau and J.-Y. Potvin, editors, Handbook of
Metaheuristics, volume 146 of International Series in Operations Research & Management Science, pages 399–419.
Qu, Y. and Bard, J. (2015). A branch-and-price-and-cut algorithm for heterogeneous pickup and delivery problems with
configurable vehicle capacity. Transportation Science, 49(2), 254–270.
13
Ritzinger, U., Puchinger, J., and Hartl, R. (2014). Dynamic programming based metaheuristics for the dial-a-ride problem.
Annals of Operations Research, pages 1–18.
Ropke, S. and Cordeau, J.-F. (2009). Branch and cut and price for the pickup and delivery problem with time windows.
Transportation Science, 43(3), 267–286.
Ropke, S. and Pisinger, D. (2006). An adaptive large neighborhood search heuristic for the pickup and delivery problem with
time windows. Transportation Science, 40, 455–472.
Ropke, S., Cordeau, J.-F., and Laporte, G. (2007). Models and branch-and-cut algorithms for pickup and delivery problems
with time windows. Networks, 49(4), 258–272.
Savelsbergh, M. (1992). The vehicle routing problem with time windows: Minimizing route duration. Operations Research
Society of America, 4(2), 146–154.
Schoenberger, J. (2016). Scheduling constraints in dial-a-ride problems with transfers: a metaheuristic approach incorporating
a cross-route scheduling procedure with postponement opportunities. Public Transport. doi:10.1007/s12469-016-0139-6.
Shaw, P. (1997). A new local search algorithm providing high quality solutions to vehicle routing problems. Technical report,
Department of Computer Science, University of Strathclyde.
Tang, J., Kong, Y., Lau, H., and Ip, A. W. (2010). A note on “Efficient feasibility testing for dial-a-ride problems”. Operations
Research Letters, 38(5), 405–407.
Vidal, T., Crainic, T. G., Gendreau, M., and Prins, C. (2014). A unified solution framework for multi-attribute vehicle routing
problems. European Journal of Operational Research, 234(3), 658–673.
14
Appendix
ALNS Parameters
We used the following parameters in the ALNS:
Parameter
Value
Start temperature control parameter
Score for new global best solution
Score for better solution
Score for worse solution
Score update factor
Minimal number of tasks to be removed per iteration
Maximal number of tasks to be removed per iteration
Noise factor
Randomization degree of worst removal heuristics
Randomization degree of Shaw removal heuristics
Randomization degree of arc frequency history removal heuristic
Randomization degree of zero split removal heuristic
Distance weight parameter of Shaw removal heuristics
Time weight parameter of Shaw removal heuristics
Load weight parameter of Shaw removal heuristics
Number of solutions to be considered for arc frequency history removal
2.5
20
20
5
0.1
0.2n
0.3n
0.035
3
9
9
6
9
9
6
10
The cooling rate was set so that the temperature in the last iteration equals 6.5% of the temperature of the
first iteration.
Detailed Computational Results
In the tables on the following pages, detailed results are presented for the pr, a, and b instance sets, for
existing approaches from the literature as well as for all configurations of our heuristic:
• number of ALNS iterations (25,000, 50,000, and 75,000)
• Balas-Simonetti local search (none, k ∈ {1, . . . , 6})
• solution of set-covering problem at the end (yes/no; time limit of 120 seconds)
The columns have the following meaning:
• BKS: best known solution
• Best: best solution value found in five runs
• Avg: average solution value over five runs
• Time: CPU times in seconds for one run (unscaled)
The last row of each table indicates the average relative gaps to the BKSs for the Best and Avg columns
and the average running time over five runs for the Time columns.
15
16
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.71%
190.02
301.34
532.00
572.70
634.69
795.01
291.71
493.66
661.34
862.65
164.46
295.96
487.93
534.99
579.59
732.56
248.21
462.93
598.35
789.59
1.20%
190.02
301.34
533.63
575.44
636.77
797.48
291.71
496.37
665.45
866.84
164.92
296.66
491.60
537.69
583.37
746.43
248.21
465.14
600.81
800.55
Avg
Without SC
Best
28.8
4.2
8.4
15.6
27.8
39.5
52.8
5.3
16.1
32.1
54.9
4.9
9.8
18.5
31.9
53.3
68.4
6.0
19.0
40.8
66.9
Time
0.48%
190.02
301.34
532.00
571.68
630.91
792.31
291.71
489.33
661.34
862.65
164.46
295.85
485.10
533.00
577.02
731.11
248.21
461.69
595.77
787.48
Best
25 000 iter
69.3
4.3
9.3
17.3
51.9
142.6
173.8
5.6
25.1
66.5
176.2
5.0
10.8
24.9
93.2
115.9
170.6
6.3
40.2
78.8
166.8
Time
0.50%
190.02
301.34
532.00
570.25
631.00
791.78
291.71
490.47
660.83
854.39
164.46
295.96
486.62
533.04
578.65
734.45
248.21
461.39
598.12
788.61
0.88%
190.02
301.34
532.40
574.11
634.38
794.92
291.71
492.91
666.42
861.75
164.46
296.27
488.29
536.62
582.26
740.49
248.21
463.54
599.78
791.01
Avg
Without SC
Best
54.7
8.4
16.9
29.5
51.7
76.3
105.4
10.5
31.0
60.4
102.6
9.6
19.1
34.7
59.0
98.0
131.2
11.6
37.1
73.5
127.5
Time
0.39%
190.02
301.34
532.00
570.25
631.00
791.78
291.71
489.33
660.83
854.39
164.46
295.66
484.83
531.41
577.52
734.45
248.21
461.39
595.27
784.07
Best
0.71%
190.02
301.34
532.40
571.82
633.90
794.92
291.71
490.82
665.40
861.74
164.46
295.88
485.77
533.64
581.04
740.49
248.21
462.28
596.97
789.76
Avg
With SC
Table 2: Own results: PR instances, No Balas-Simonetti
0.92%
190.02
301.34
533.00
573.25
635.33
796.44
291.71
492.27
663.37
866.13
164.46
296.26
486.85
535.12
580.42
746.13
248.21
463.90
597.46
798.50
Avg
With SC
50 000 iter
108.1
8.6
18.8
32.6
81.9
198.1
227.6
11.0
39.9
148.6
225.3
9.9
20.8
42.1
168.3
200.8
254.3
12.1
68.6
170.2
222.5
Time
0.53%
190.02
301.34
532.00
571.62
632.14
790.29
291.71
489.92
659.62
858.14
164.46
295.96
485.75
532.39
578.71
740.00
248.21
461.39
597.84
787.44
0.82%
190.02
301.34
532.61
574.69
634.11
793.37
291.71
492.47
662.02
861.11
164.46
296.47
487.63
536.66
579.67
742.10
248.21
463.27
599.46
792.68
Avg
Without SC
Best
83.1
12.5
25.6
46.1
77.7
115.0
159.2
15.7
47.1
93.0
163.9
14.5
28.6
51.6
89.1
147.2
194.7
17.5
56.6
116.2
189.3
Time
0.44%
190.02
301.34
532.00
570.29
630.92
790.29
291.71
489.33
658.18
858.14
164.46
295.66
484.83
531.53
578.02
740.00
248.21
461.22
596.68
785.60
Best
75 000 iter
0.66%
190.02
301.34
532.20
572.77
633.06
793.07
291.71
490.69
660.91
861.11
164.46
295.90
485.20
534.02
579.48
742.10
248.21
461.85
597.90
790.55
Avg
With SC
142.9
12.6
28.2
51.6
144.8
237.7
283.0
16.4
73.5
161.8
288.8
14.8
31.2
59.0
211.1
270.2
319.8
18.1
98.8
239.2
298.2
Time
17
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.71%
190.02
301.34
532.00
571.78
634.17
791.03
291.71
487.84
666.56
861.54
164.46
295.66
488.63
536.50
580.49
736.83
248.21
461.39
596.88
795.49
1.16%
190.02
301.43
535.73
575.63
636.91
794.49
291.71
493.39
669.43
869.35
164.54
297.03
490.49
538.70
585.09
740.80
248.21
462.99
600.86
800.15
Avg
Without SC
Best
32.3
4.7
10.2
18.1
30.9
45.6
61.3
6.2
18.5
35.4
61.4
5.1
11.4
21.1
36.3
58.9
74.9
6.6
20.9
43.7
74.4
Time
0.50%
190.02
301.34
532.00
571.25
631.84
788.46
291.71
487.84
665.27
859.57
164.46
295.66
485.63
532.33
580.49
730.09
248.21
461.39
594.44
794.03
Best
ALNS-k=1
59.4
4.8
10.5
20.0
37.5
136.9
166.1
6.2
19.5
41.5
141.1
5.1
11.7
22.5
43.6
114.2
185.0
6.7
21.8
55.2
137.2
Time
0.69%
190.02
301.34
532.00
573.96
634.93
793.27
291.71
491.26
666.05
853.64
164.46
295.96
488.30
532.05
579.71
735.87
248.21
461.39
597.38
795.74
1.13%
190.02
301.34
532.30
578.32
637.36
795.06
291.71
494.57
670.13
863.86
164.94
296.58
489.60
537.82
581.50
744.04
248.21
463.81
600.73
800.01
Avg
Without SC
Best
39.7
5.1
11.5
18.7
35.6
54.7
78.3
6.5
20.8
39.1
74.5
5.6
13.3
24.9
44.4
77.0
102.5
7.2
25.3
58.2
90.8
Time
0.47%
190.02
301.34
532.00
571.10
632.67
788.95
291.71
490.75
664.31
852.37
164.46
295.66
484.83
532.05
579.53
734.68
248.21
461.39
594.14
790.09
Best
0.83%
190.02
301.34
532.20
573.44
634.43
793.13
291.71
491.75
666.62
861.26
164.54
296.13
487.32
534.34
580.49
742.70
248.21
462.59
598.13
796.48
Avg
With SC
Table 3: Own results: PR instances, 25 000 iterations, part 1/2
0.85%
190.02
301.34
534.35
573.23
634.64
791.96
291.71
492.18
667.95
863.72
164.54
296.25
487.69
533.90
583.75
737.22
248.21
462.24
597.75
796.27
Avg
With SC
ALNS-k=2
65.9
5.1
11.8
19.1
46.4
154.6
185.0
6.5
21.6
49.7
137.8
5.6
13.6
26.1
55.5
106.3
223.0
7.2
26.5
90.3
127.2
Time
0.53%
190.02
301.34
532.00
571.41
633.24
792.70
291.71
491.26
662.80
855.42
164.46
295.66
485.82
532.54
577.24
736.24
248.21
462.21
595.17
787.63
0.99%
190.02
301.71
532.20
577.65
637.82
796.77
291.71
493.84
665.47
861.61
164.46
296.96
489.42
535.19
581.27
741.66
248.21
463.95
600.27
793.41
Avg
Without SC
Best
67.8
5.1
15.2
21.7
49.6
72.0
109.7
6.9
25.8
50.6
102.9
6.2
22.3
40.2
69.6
169.1
226.2
8.6
43.6
126.4
183.6
Time
0.40%
190.02
301.34
532.00
571.25
629.87
789.51
291.71
489.33
660.57
854.65
164.46
295.66
484.83
530.88
577.24
735.60
248.21
461.69
595.17
787.52
Best
ALNS-k=3
0.71%
190.02
301.51
532.20
574.17
633.70
792.11
291.71
492.59
663.62
859.29
164.46
296.30
487.09
532.09
578.88
740.36
248.21
462.54
598.46
791.40
Avg
With SC
94.5
5.1
15.5
22.0
57.6
151.3
230.2
6.9
26.9
54.1
184.9
6.3
22.5
41.1
77.5
203.5
346.7
8.6
46.1
167.5
214.8
Time
18
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.65%
190.02
301.34
532.00
573.27
635.16
791.56
291.71
491.02
661.40
859.82
164.46
297.22
485.63
534.02
580.67
736.07
248.21
462.07
595.93
789.43
0.98%
190.02
301.34
532.50
578.02
637.17
792.74
291.71
495.21
664.90
864.52
164.46
297.70
488.50
535.76
581.68
739.94
248.21
464.68
598.48
793.32
Avg
Without SC
Best
151.8
5.3
18.9
28.1
77.9
111.5
151.3
7.7
38.5
75.9
160.2
8.4
41.4
82.7
136.5
597.5
686.1
12.9
84.3
289.4
422.4
Time
0.45%
190.02
301.34
532.00
571.80
633.54
789.57
291.71
491.02
661.19
855.84
164.46
295.66
484.83
530.48
577.24
736.07
248.21
461.69
593.45
787.69
Best
ALNS-k=4
180.5
5.3
19.1
28.4
87.7
231.7
262.3
7.8
39.7
81.5
280.5
8.4
41.6
83.6
143.1
643.1
806.5
12.9
86.6
300.1
440.7
Time
0.49%
190.02
301.34
532.00
572.63
631.14
790.67
291.71
491.26
662.24
852.51
164.46
295.66
485.63
535.41
577.24
735.88
248.21
461.07
594.14
788.89
Best
0.86%
190.02
301.34
532.46
576.22
634.92
792.44
291.71
494.63
664.38
858.80
164.46
296.20
487.81
537.28
581.95
740.79
248.21
463.17
597.23
793.77
Avg
Without SC
366.8
5.7
25.4
33.1
112.3
165.5
245.8
8.4
52.1
112.4
254.3
11.7
65.5
164.6
297.7
1810.6
1953.3
17.8
134.5
745.8
1119.9
Time
0.32%
190.02
301.34
532.00
571.25
629.85
788.98
291.71
491.02
660.57
851.57
164.46
295.66
484.83
530.28
577.18
732.33
248.21
458.73
593.78
787.16
Best
0.65%
190.02
301.34
532.29
574.96
633.92
789.73
291.71
492.76
662.72
858.27
164.46
295.92
486.06
532.47
579.47
739.49
248.21
461.43
596.64
790.48
Avg
With SC
Table 4: Own results: PR instances, 25 000 iterations, part 2/2
0.74%
190.02
301.34
532.00
574.74
636.23
791.25
291.71
492.75
663.29
863.58
164.46
296.64
486.21
532.75
579.67
739.67
248.21
462.69
595.13
792.31
Avg
With SC
ALNS-k=5
392.9
5.7
25.6
33.6
118.8
255.7
363.8
8.4
53.8
115.5
326.9
11.7
65.7
165.2
310.1
1869.7
2069.3
17.8
135.2
750.5
1155.9
Time
0.50%
190.02
301.34
532.00
573.27
631.34
792.08
291.71
487.84
660.57
860.67
164.46
295.66
485.63
532.15
578.60
731.95
248.21
462.61
595.95
789.36
Best
0.88%
190.02
301.34
532.85
575.65
635.18
793.62
291.71
492.33
663.64
866.07
164.46
295.84
488.29
535.05
581.86
736.94
248.21
463.84
599.35
797.36
Avg
Without SC
640.0
6.1
34.7
39.7
175.1
265.7
317.0
9.3
65.5
158.0
323.4
18.6
99.9
296.6
537.0
2854.4
3594.3
26.3
224.6
1470.8
2283.5
Time
0.39%
190.02
301.34
532.00
570.89
627.04
788.93
291.71
487.84
659.69
860.41
164.46
295.66
484.83
532.15
578.26
731.95
248.21
462.34
595.13
789.01
Best
ALNS-k=6
0.71%
190.02
301.34
532.49
573.79
632.25
791.96
291.71
490.88
662.00
865.20
164.46
295.84
486.60
532.92
579.94
735.63
248.21
463.23
597.38
796.77
Avg
With SC
670.8
6.1
35.0
40.1
180.1
365.0
431.5
9.3
66.8
165.9
440.4
18.6
100.1
297.3
552.0
2896.9
3689.1
26.4
225.7
1495.4
2374.5
Time
19
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.55%
190.02
301.34
532.00
571.62
632.25
791.52
291.71
490.47
660.91
854.04
164.46
295.96
488.30
535.24
579.13
736.28
248.21
462.18
594.69
787.61
0.91%
190.02
301.34
532.61
572.88
634.69
794.23
291.71
492.18
665.61
864.28
164.46
296.50
489.27
538.43
581.60
743.05
248.21
462.57
600.07
792.14
Avg
Without SC
Best
66.9
9.5
20.2
35.9
59.6
93.5
128.3
12.6
36.8
71.5
131.2
10.3
22.8
42.6
76.5
122.8
163.7
13.1
43.2
91.7
151.8
Time
0.37%
190.02
301.34
532.00
570.55
629.24
791.52
291.71
490.47
659.87
853.56
164.46
295.66
484.83
532.39
577.88
734.89
248.21
458.73
594.17
787.42
Best
ALNS-k=1
100.4
9.5
20.7
37.0
68.4
212.5
249.4
12.7
38.7
80.8
228.9
10.3
23.2
45.3
117.5
200.2
285.0
13.2
46.0
114.4
193.8
Time
0.50%
190.02
301.34
532.00
572.02
631.88
788.59
291.71
491.02
660.41
853.69
164.46
295.66
486.62
534.99
578.31
733.62
248.21
461.69
595.13
790.71
0.81%
190.02
301.34
532.49
574.72
635.07
791.91
291.71
493.23
662.99
861.55
164.46
296.55
488.45
536.39
579.99
737.77
248.21
462.56
599.57
792.17
Avg
Without SC
Best
79.9
9.8
22.5
38.7
72.3
109.0
156.7
12.6
40.6
81.1
156.5
11.0
25.8
48.6
85.7
149.9
205.8
13.8
48.5
115.4
192.9
Time
0.33%
190.02
301.34
532.00
570.25
629.57
787.21
291.71
490.47
659.70
853.57
164.46
295.66
484.83
530.60
577.36
732.79
248.21
459.37
595.07
787.86
Best
0.57%
190.02
301.34
532.20
571.07
632.37
790.59
291.71
491.50
661.97
858.86
164.46
295.91
485.96
532.02
578.36
737.58
248.21
461.25
598.31
790.57
Avg
With SC
Table 5: Own results: PR instances, 50 000 iterations, part 1/2
0.68%
190.02
301.34
532.48
571.53
633.72
793.85
291.71
491.17
663.15
862.63
164.46
295.92
486.03
533.26
579.75
741.83
248.21
461.26
596.07
791.06
Avg
With SC
ALNS-k=2
116.3
9.8
22.9
39.5
87.7
227.6
277.6
12.7
42.0
95.5
260.6
11.0
26.0
49.8
105.2
205.1
326.8
13.8
52.2
199.6
261.0
Time
0.48%
190.02
301.34
532.00
571.62
631.74
791.56
291.71
489.52
661.40
854.95
164.46
295.96
486.62
532.64
577.24
733.51
248.21
461.69
597.07
787.26
0.79%
190.02
301.34
532.79
575.40
633.00
795.15
291.71
491.94
662.21
859.96
164.46
297.00
487.58
535.43
580.10
737.16
248.21
462.86
599.31
793.40
Avg
Without SC
Best
121.9
9.6
26.9
41.0
86.7
132.6
195.3
13.9
52.9
98.3
183.9
12.0
34.8
69.2
129.6
311.0
405.3
16.1
71.1
211.9
334.9
Time
0.39%
190.02
301.34
532.00
571.25
630.50
790.32
291.71
489.52
659.44
854.95
164.46
295.66
484.83
530.88
577.24
733.44
248.21
461.69
595.18
787.12
Best
ALNS-k=3
0.58%
190.02
301.34
532.20
572.55
631.90
794.45
291.71
490.77
661.04
858.74
164.46
296.10
485.15
532.21
577.96
737.13
248.21
462.06
596.44
790.92
Avg
With SC
159.3
9.6
27.3
42.0
104.2
253.1
316.0
14.0
54.8
111.3
299.3
12.0
35.1
69.9
163.9
380.1
526.0
16.1
76.8
264.3
409.8
Time
20
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.47%
190.02
301.34
532.00
572.15
632.32
790.82
291.71
487.84
660.29
854.17
164.46
295.66
485.63
533.25
579.50
734.33
248.21
461.07
595.97
789.58
Best
0.79%
190.02
301.34
532.20
574.06
634.30
791.41
291.71
491.95
663.77
862.43
164.46
297.17
486.28
535.50
582.13
738.02
248.21
462.66
598.23
794.57
Avg
Without SC
255.1
10.0
33.3
49.5
124.9
197.7
261.7
14.0
65.7
133.8
251.9
15.4
62.0
135.9
233.7
1023.0
1069.1
19.8
127.6
476.6
796.5
Time
0.33%
190.02
301.34
532.00
570.45
631.42
789.69
291.71
487.84
660.02
851.82
164.46
295.66
484.83
530.61
578.51
734.33
248.21
458.73
594.14
787.13
Best
ALNS-k=4
297.1
10.0
33.6
50.2
145.1
311.1
382.3
14.1
67.2
153.6
353.8
15.4
62.4
136.7
284.2
1143.5
1189.8
19.9
133.4
525.1
910.9
Time
0.42%
190.02
301.34
532.00
571.62
631.89
789.35
291.71
491.02
659.71
850.53
164.46
295.96
485.82
532.33
577.24
735.78
248.21
461.12
595.02
785.85
Best
0.71%
190.02
301.34
532.20
572.39
635.06
790.68
291.71
492.95
662.86
859.21
164.46
296.54
487.44
533.35
579.63
738.90
248.21
462.91
598.13
790.98
Avg
Without SC
545.5
10.6
43.0
55.2
195.2
263.1
394.5
15.5
84.6
185.4
417.1
17.7
117.5
238.1
491.7
2454.8
2955.2
28.8
227.7
1066.4
1647.1
Time
0.30%
190.02
301.34
532.00
570.25
631.20
789.14
291.71
489.33
656.56
850.53
164.46
295.66
484.83
529.39
577.24
735.78
248.21
461.12
593.76
785.85
Best
0.52%
190.02
301.34
532.00
570.63
632.79
789.79
291.71
490.38
660.17
858.26
164.46
296.11
485.15
531.46
578.93
738.77
248.21
461.57
596.41
788.79
Avg
With SC
Table 6: Own results: PR instances, 50 000 iterations, part 2/2
0.61%
190.02
301.34
532.12
571.67
632.80
790.64
291.71
489.94
662.11
861.56
164.46
296.29
484.99
532.74
581.25
737.83
248.21
461.15
595.40
793.30
Avg
With SC
ALNS-k=5
580.5
10.6
43.4
55.6
210.1
367.1
515.3
15.5
86.0
207.5
537.7
17.8
117.8
238.8
533.7
2533.6
3075.9
28.8
231.0
1094.4
1689.7
Time
0.43%
190.02
301.34
532.00
571.78
627.02
791.23
291.71
491.26
658.48
856.01
164.46
295.66
485.63
532.39
577.52
732.24
248.21
461.69
597.73
787.39
Best
0.71%
190.02
301.34
533.29
573.21
633.42
791.80
291.71
493.73
663.60
859.15
164.46
296.80
487.56
533.64
578.86
735.54
248.21
462.26
599.46
790.59
Avg
Without SC
1026.5
11.2
54.5
72.9
270.2
389.6
525.9
16.6
109.2
266.1
545.6
24.7
208.4
403.1
834.1
5474.7
5347.2
41.1
400.0
2237.1
3298.0
Time
0.26%
190.02
301.34
532.00
570.29
626.93
789.27
291.71
491.02
655.09
853.72
164.46
295.66
484.83
530.88
577.24
729.03
248.21
461.48
593.25
786.46
Best
ALNS-k=6
0.53%
190.02
301.34
532.41
571.18
632.85
791.10
291.71
492.16
661.30
857.63
164.46
296.02
485.47
531.63
577.66
734.48
248.21
462.05
596.05
789.78
Avg
With SC
1063.7
11.2
54.9
74.0
289.6
494.8
646.5
16.6
113.3
277.1
658.5
24.7
208.8
404.3
853.5
5543.8
5467.8
41.1
403.5
2313.3
3376.8
Time
21
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.55%
190.02
301.34
532.00
571.00
634.01
791.06
291.71
489.92
661.23
857.82
164.46
295.66
485.75
530.48
580.47
739.02
248.21
461.39
595.55
790.45
0.82%
190.02
301.34
532.00
571.97
635.22
795.24
291.71
490.72
663.47
861.47
164.46
296.42
489.00
534.40
582.04
741.59
248.21
463.15
599.01
794.10
Avg
Without SC
Best
98.8
14.4
31.1
54.5
93.3
146.6
190.7
18.8
55.3
106.4
188.4
15.7
33.8
62.7
109.7
171.3
235.8
19.7
64.0
133.1
231.6
Time
0.35%
190.02
301.34
532.00
570.25
630.37
788.92
291.71
489.33
659.82
849.60
164.46
295.66
484.83
530.23
577.24
739.00
248.21
461.39
595.03
785.34
Best
ALNS-k=1
141.2
14.4
31.7
55.5
109.9
267.8
312.4
18.9
57.1
124.9
307.7
15.7
34.3
65.5
160.5
288.5
358.0
19.8
74.4
222.3
284.2
Time
0.50%
190.02
301.34
532.00
572.15
633.52
791.56
291.71
491.02
660.57
857.14
164.46
295.96
485.82
532.15
577.00
734.37
248.21
461.12
597.23
786.03
0.76%
190.02
301.34
532.65
573.74
634.95
793.48
291.71
492.24
661.56
860.61
164.46
296.64
488.04
535.35
578.80
741.32
248.21
462.67
597.94
790.30
Avg
Without SC
Best
117.5
14.7
32.9
56.6
102.9
168.4
225.2
19.5
64.1
121.7
224.8
16.1
37.0
71.7
128.2
223.5
304.1
20.4
69.7
171.8
277.0
Time
0.33%
190.02
301.34
532.00
570.45
629.14
789.03
291.71
490.47
659.71
856.91
164.46
295.66
484.83
531.01
577.00
734.37
248.21
458.73
593.61
785.60
Best
0.56%
190.02
301.34
532.40
571.45
632.77
791.95
291.71
490.79
660.83
860.57
164.46
296.04
485.27
532.54
577.53
741.32
248.21
461.51
594.98
787.16
Avg
With SC
Table 7: Own results: PR instances, 75 000 iterations, part 1/2
0.59%
190.02
301.34
532.00
570.78
633.22
792.77
291.71
489.70
661.83
858.72
164.46
296.14
486.06
531.84
579.76
741.58
248.21
462.41
596.49
787.48
Avg
With SC
ALNS-k=2
157.3
14.8
33.4
58.1
121.1
289.4
346.5
19.6
66.3
134.0
346.0
16.1
37.5
73.7
181.7
309.2
425.4
20.4
75.4
239.8
337.4
Time
0.45%
190.02
301.34
532.00
571.41
631.91
789.77
291.71
491.26
660.02
853.07
164.46
295.96
485.82
533.22
577.24
731.50
248.21
461.48
596.80
787.76
0.65%
190.02
301.49
532.20
571.93
633.66
791.15
291.71
492.59
661.09
857.66
164.46
296.99
487.19
533.93
578.74
736.34
248.21
462.27
598.42
790.50
Avg
Without SC
Best
170.4
15.1
40.5
61.2
124.0
181.6
276.7
19.6
71.2
145.2
268.3
17.7
47.8
99.9
166.2
403.1
571.6
22.8
98.6
285.0
492.8
Time
0.32%
190.02
301.34
532.00
570.25
628.59
789.36
291.71
489.83
659.69
853.07
164.46
295.66
484.83
531.19
576.70
731.50
248.21
461.48
593.83
787.14
Best
ALNS-k=3
0.50%
190.02
301.34
532.01
570.61
630.99
790.44
291.71
491.13
660.13
857.18
164.46
296.22
484.83
531.92
578.17
736.08
248.21
461.67
596.77
789.83
Avg
With SC
209.5
15.1
41.1
62.1
138.7
267.4
397.5
19.7
74.1
151.7
389.2
17.7
48.1
101.3
204.2
491.6
692.6
22.8
103.0
361.4
591.6
Time
22
190.02
301.34
532.00
570.25
625.64
783.78
291.71
487.84
653.94
845.47
164.46
295.66
484.83
529.33
573.56
725.22
248.21
458.73
592.23
783.81
pr01
pr02
pr03
pr04
pr05
pr06
pr07
pr08
pr09
pr10
pr11
pr12
pr13
pr14
pr15
pr16
pr17
pr18
pr19
pr20
Avg
BKS
Instance
0.41%
190.02
301.34
532.00
571.13
630.58
789.43
291.71
489.92
659.03
851.93
164.46
295.96
485.63
532.33
578.35
733.61
248.21
462.08
595.57
788.02
Best
0.66%
190.02
301.34
532.00
572.69
633.09
791.13
291.71
492.80
660.27
859.07
164.46
296.76
485.70
533.56
580.93
736.67
248.21
463.60
597.67
791.26
Avg
Without SC
341.1
15.1
46.0
68.2
183.0
288.0
367.9
21.0
93.0
187.8
381.2
20.9
77.5
192.4
304.5
1210.5
1509.2
29.0
168.7
662.1
996.7
Time
0.29%
190.02
301.34
532.00
570.25
630.58
788.80
291.71
489.33
658.14
847.40
164.46
295.66
484.83
530.18
577.24
733.37
248.21
461.69
594.56
785.12
Best
ALNS-k=4
383.8
15.1
46.5
68.8
205.1
408.6
488.7
21.1
98.9
194.8
487.0
20.9
77.9
193.2
342.2
1329.1
1630.1
29.1
177.3
754.8
1085.8
Time
0.39%
190.02
301.34
532.00
571.25
630.25
790.09
291.71
489.52
659.69
854.19
164.46
295.66
484.83
532.33
576.78
730.79
248.21
461.39
596.34
789.26
Best
0.62%
190.02
301.34
532.20
572.86
632.44
791.15
291.71
492.81
662.89
859.31
164.46
296.20
485.70
533.38
577.40
736.56
248.21
462.62
596.96
790.99
Avg
Without SC
727.7
15.4
63.3
85.3
253.1
405.3
541.1
22.8
123.4
235.6
532.4
24.8
121.8
345.3
631.9
3091.0
3835.6
39.1
287.4
1440.1
2459.5
Time
0.29%
190.02
301.34
532.00
570.29
628.48
787.84
291.71
489.33
659.69
854.19
164.46
295.66
484.83
531.03
576.51
730.07
248.21
461.21
592.93
787.12
Best
0.46%
190.02
301.34
532.20
570.88
629.21
789.91
291.71
490.37
661.72
857.97
164.46
296.20
484.99
531.97
577.15
735.53
248.21
462.15
594.31
789.31
Avg
With SC
Table 8: Own results: PR instances, 75 000 iterations, part 2/2
0.50%
190.02
301.34
532.00
570.62
631.98
790.14
291.71
491.22
659.38
857.58
164.46
296.02
484.83
531.21
579.42
736.62
248.21
462.25
596.08
788.58
Avg
With SC
ALNS-k=5
767.2
15.4
63.9
86.4
272.9
514.2
661.9
22.9
125.7
269.4
653.2
24.8
122.2
346.3
688.9
3137.8
3956.7
39.1
293.0
1493.6
2555.7
Time
0.35%
190.02
301.34
532.00
572.77
632.20
789.43
291.71
487.84
660.51
856.11
164.46
295.96
485.63
533.28
573.56
731.96
248.21
458.73
595.15
783.81
Best
0.66%
190.02
301.34
532.00
574.05
635.53
791.62
291.71
490.81
662.78
859.34
164.74
296.23
486.40
535.50
578.13
735.87
248.21
461.06
597.58
790.61
Avg
Without SC
1368.6
16.4
74.0
95.4
390.8
533.4
697.1
24.9
144.9
326.0
667.3
36.0
226.0
496.2
1213.3
6107.3
7704.3
50.8
445.7
3106.3
5015.4
Time
0.24%
190.02
301.34
532.00
570.45
631.81
789.43
291.71
487.84
659.71
851.24
164.46
295.66
484.83
531.25
573.56
731.96
248.21
458.73
592.93
783.81
Best
ALNS-k=6
0.48%
190.02
301.34
532.00
571.33
634.67
790.49
291.71
490.23
661.38
857.68
164.46
295.66
484.83
532.26
577.19
735.49
248.21
460.02
594.85
789.09
Avg
With SC
1413.6
16.4
74.5
96.2
422.4
654.0
818.0
25.0
147.9
383.3
788.1
36.0
226.3
497.0
1315.4
6182.1
7825.3
50.8
447.3
3156.8
5109.8
Time
23
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Opt
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Instance
a Instances
0.00%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.62
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Best
0.01%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.62
808.42
604.12
819.25
916.05
724.04
889.30
1033.38
747.46
945.73
1232.03
Avg
0.00%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.58
747.46
945.82
1230.56
Best
0.07%
294.25
344.83
431.12
344.90
496.09
583.19
485.50
557.69
668.82
498.41
686.70
808.42
604.12
819.99
916.97
724.69
889.83
1035.23
748.21
947.05
1233.88
Avg
61.3
3.0
7.8
9.0
7.8
13.8
22.8
15.0
21.0
43.8
22.8
43.2
67.8
31.2
61.8
120.0
45.0
78.0
190.8
58.2
154.8
268.8
Time
Chassaing et al. (ELS)
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Opt
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Instance
b Instances
0.00%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.81
839.89
1036.34
1185.65
Best
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.49
839.89
1036.34
1185.88
Avg
30.6
12.8
10.0
16.6
13.2
18.0
20.2
14.4
26.8
34.8
22.6
29.6
41.4
25.0
35.6
51.6
31.8
39.8
54.2
34.2
47.6
63.2
Time
Braekers et al. (TA)
Table 9: State-of-the-art results from the literature for a and b instances
33.8
8.6
20.2
17.4
16.6
18.8
28.4
25.6
26.4
35.4
21.8
30.6
43.8
30.6
37.0
53.6
32.4
43.6
58.2
37.8
57.6
66.4
Time
Braekers et al. (TA)
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.21
613.72
761.40
902.04
714.83
860.07
978.57
824.38
912.62
1203.37
840.48
1036.65
1186.97
Best
0.05%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.89
613.72
761.70
902.13
714.90
860.07
978.76
826.44
912.62
1205.54
840.73
1036.86
1187.80
Avg
60.9
4.2
6.0
10.8
7.8
13.2
19.8
12.0
27.0
46.8
21.0
40.2
81.0
28.8
55.8
120.0
49.2
100.2
181.8
70.2
103.8
280.2
Time
Chassaing et al. (ELS)
24
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.14%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.48
819.25
918.13
724.09
892.30
1037.65
752.18
950.65
1235.90
0.32%
294.82
344.83
431.12
344.83
494.85
583.21
485.50
557.79
669.98
498.41
686.93
811.85
605.05
820.80
922.90
726.61
894.51
1041.31
754.00
957.05
1240.30
Avg
Without SC
Best
8.97
1.9
3.2
4.5
2.9
4.4
5.4
4.1
5.5
7.9
5.9
8.7
10.7
6.8
9.7
14.0
8.4
12.3
17.0
10.4
16.8
20.7
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
918.13
724.04
889.12
1033.37
747.46
947.69
1233.87
Best
25 000 iter
11.86
1.9
3.2
4.6
2.9
4.4
5.7
4.2
5.6
8.7
6.1
9.6
11.9
7.1
11.0
18.3
9.3
13.6
22.4
11.5
32.0
45.1
Time
0.16%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
812.31
604.12
819.25
918.78
724.04
894.56
1036.68
748.83
953.62
1236.04
0.28%
294.63
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.37
498.41
686.63
812.80
604.23
821.90
922.28
724.94
896.08
1038.69
752.17
957.26
1238.82
Avg
Without SC
Best
17.59
3.8
6.2
8.5
5.6
8.6
11.4
7.8
10.5
15.5
11.3
17.2
20.9
13.3
19.1
27.0
16.3
24.4
33.5
20.8
33.2
40.6
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
917.31
724.04
889.12
1033.37
747.46
950.16
1232.95
Best
0.07%
294.63
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.72
604.12
819.51
917.91
724.04
889.54
1034.27
747.46
951.52
1234.25
Avg
With SC
Table 10: Own results: A instances, No Balas-Simonetti
0.11%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.71
498.41
686.66
808.87
604.19
819.49
920.44
724.04
889.67
1035.06
747.90
952.33
1236.08
Avg
With SC
50 000 iter
24.15
3.8
6.2
8.5
5.7
8.7
11.7
7.9
10.7
17.2
11.7
18.9
23.3
13.9
21.5
33.9
17.6
26.9
41.8
22.7
77.9
96.2
Time
0.12%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
820.30
918.58
724.04
891.51
1035.89
750.25
950.77
1236.76
0.21%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.55
498.41
686.63
810.36
604.12
820.64
921.03
724.37
892.80
1037.95
752.39
952.78
1239.17
Avg
Without SC
Best
26.46
5.9
9.3
13.2
8.3
13.0
16.4
11.6
15.8
23.8
17.2
25.7
32.2
20.2
28.7
40.7
24.2
37.2
50.4
31.2
48.5
61.6
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.88
724.04
889.12
1033.37
747.46
946.81
1232.12
Best
75 000 iter
0.04%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.71
604.12
819.35
917.66
724.04
889.30
1033.88
747.46
948.70
1233.23
Avg
With SC
33.25
5.9
9.4
13.2
8.4
13.1
16.9
11.7
16.1
26.1
17.7
28.3
35.9
21.0
32.3
50.7
26.1
41.0
66.1
34.0
82.3
114.6
Time
25
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.22%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.36
498.41
686.63
812.36
604.48
820.94
919.21
724.04
894.61
1037.39
750.48
955.41
1237.14
0.33%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
671.75
498.41
687.23
813.17
604.61
822.09
921.13
725.13
898.03
1040.16
752.77
956.28
1239.65
Avg
Without SC
Best
10.97
2.4
3.8
5.4
3.5
5.4
6.9
5.2
6.8
10.1
7.1
10.7
13.2
8.3
11.4
16.7
10.4
15.0
20.6
12.9
20.8
25.2
Time
0.06%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.84
604.12
819.25
917.85
724.04
889.12
1033.61
747.46
950.79
1233.48
Best
ALNS-k=1
12.84
2.4
3.9
5.4
3.5
5.4
7.0
5.2
6.9
10.7
7.2
11.2
14.1
8.5
12.0
18.8
10.8
15.6
26.3
13.4
27.9
43.0
Time
0.17%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.58
498.41
686.63
810.29
604.12
819.25
918.89
724.04
895.35
1034.66
753.16
949.83
1237.48
0.33%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.85
498.41
686.78
813.18
604.97
822.01
923.16
724.77
897.85
1038.44
754.16
955.32
1240.68
Avg
Without SC
Best
11.47
2.5
3.9
5.4
3.6
5.6
7.0
5.1
6.7
10.3
7.1
11.5
13.9
8.5
12.2
17.9
10.3
15.4
22.3
13.4
22.1
27.1
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
917.17
724.04
889.58
1033.37
747.46
947.70
1234.85
Best
0.10%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.13
498.41
686.63
809.16
604.19
819.76
919.05
724.04
890.23
1035.42
748.00
951.31
1235.31
Avg
With SC
Table 11: Own results: A instances, 25 000 iterations, part 1/2
0.11%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.22
498.41
686.85
810.08
604.12
819.51
919.25
724.04
889.40
1036.14
747.73
952.13
1236.39
Avg
With SC
ALNS-k=2
13.16
2.5
3.9
5.4
3.6
5.6
7.1
5.1
6.7
10.8
7.2
11.9
14.7
8.6
12.8
19.8
10.7
15.9
27.4
13.9
31.7
40.3
Time
0.18%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
812.47
604.12
820.22
921.74
724.04
892.32
1033.62
750.44
952.47
1239.06
0.31%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.74
670.21
498.41
686.78
813.63
604.92
821.69
922.58
724.56
896.11
1037.91
753.22
955.88
1242.31
Avg
Without SC
Best
11.79
2.4
4.0
5.4
3.6
5.7
7.1
5.1
6.6
10.5
7.1
11.7
14.2
8.5
12.3
18.8
10.5
15.8
22.8
14.0
23.6
28.4
Time
0.05%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
819.25
918.96
724.04
889.12
1033.37
747.46
948.46
1234.86
Best
ALNS-k=3
0.11%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.93
498.41
686.63
810.55
604.19
819.44
920.38
724.04
889.58
1035.12
748.37
950.82
1235.62
Avg
With SC
13.49
2.4
4.0
5.4
3.6
5.7
7.2
5.1
6.6
10.9
7.2
12.0
15.1
8.6
12.8
20.8
10.9
16.3
26.0
14.6
35.4
41.6
Time
26
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.14%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.37
498.41
686.63
808.48
604.12
820.30
919.10
724.04
894.61
1035.67
749.37
951.77
1236.00
0.32%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
671.19
498.41
686.63
812.47
604.57
822.59
920.95
726.80
896.25
1040.68
753.95
955.38
1238.60
Avg
Without SC
Best
12.41
2.5
4.0
5.4
3.6
5.8
7.1
5.2
6.8
11.5
7.4
11.9
15.0
8.9
13.1
19.9
11.1
16.7
25.1
14.6
24.9
30.2
Time
0.03%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
918.08
724.04
889.12
1033.43
747.46
947.73
1232.80
Best
ALNS-k=4
13.72
2.5
4.0
5.4
3.6
5.8
7.2
5.2
6.8
12.0
7.5
12.3
15.8
9.1
13.6
21.6
11.5
17.2
28.2
15.4
33.9
38.3
Time
0.16%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
812.73
604.12
819.25
918.78
724.04
889.58
1035.79
751.92
955.15
1235.48
0.31%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.74
670.03
498.41
686.74
814.23
604.31
821.51
921.00
725.75
894.82
1038.91
753.24
957.47
1241.47
Avg
Without SC
Best
13.55
2.5
4.0
5.4
3.7
5.8
7.3
5.5
7.0
12.2
7.6
13.2
16.3
9.3
14.6
22.1
12.1
18.2
27.6
16.1
29.0
34.0
Time
0.05%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
819.25
917.23
724.04
889.12
1033.58
747.46
950.13
1234.55
Best
0.10%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.25
498.41
686.63
810.26
604.19
819.25
918.23
724.04
890.22
1034.63
748.12
952.11
1236.01
Avg
With SC
Table 12: Own results: A instances, 25 000 iterations, part 2/2
0.10%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.55
498.41
686.63
809.64
604.19
819.46
918.89
724.04
889.87
1034.71
748.81
951.35
1235.04
Avg
With SC
ALNS-k=5
16.73
2.5
4.0
5.4
3.7
5.8
7.4
5.5
7.0
12.7
7.7
13.6
17.3
9.5
15.1
24.0
12.5
18.7
30.4
16.7
42.8
74.8
Time
0.22%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
812.53
604.12
820.34
923.38
725.68
892.32
1036.71
751.57
951.53
1240.95
0.36%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.74
670.64
498.41
686.78
813.48
604.43
821.88
925.55
727.15
896.31
1040.13
753.10
955.05
1243.69
Avg
Without SC
Best
15.06
2.4
3.9
5.6
3.7
6.0
7.8
5.6
7.3
14.4
8.1
14.5
19.1
10.3
16.4
25.3
13.0
20.1
30.9
17.7
31.9
39.6
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
819.25
917.31
724.04
889.12
1034.83
747.46
947.75
1234.41
Best
ALNS-k=6
0.11%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
809.85
604.12
819.44
919.12
724.04
889.49
1036.25
748.71
951.13
1236.65
Avg
With SC
17.37
2.4
3.9
5.6
3.7
6.0
7.9
5.6
7.3
15.0
8.1
14.8
19.9
10.4
16.8
27.8
13.4
20.6
35.8
18.4
46.9
59.4
Time
27
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.13%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
821.43
917.85
724.04
892.65
1034.84
750.74
951.46
1235.69
0.27%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.19
498.41
686.89
812.83
604.19
822.19
920.91
725.03
895.23
1036.97
752.81
954.19
1242.06
Avg
Without SC
Best
22.31
4.8
7.9
11.1
7.0
11.0
13.7
10.2
13.2
19.7
14.1
21.7
26.7
16.6
23.7
34.3
20.2
30.6
43.6
26.2
42.0
52.7
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.88
724.04
889.12
1033.37
747.46
949.03
1233.83
Best
ALNS-k=1
26.11
4.8
7.9
11.1
7.1
11.0
13.9
10.3
13.3
20.5
14.2
22.5
28.3
16.9
24.7
37.5
20.8
31.6
47.2
27.1
57.7
98.5
Time
0.15%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
811.31
604.12
820.30
919.81
724.04
892.32
1038.07
750.01
950.28
1235.82
0.25%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.33
498.41
686.63
812.82
604.23
822.50
920.78
724.39
893.48
1039.60
752.12
952.08
1239.44
Avg
Without SC
Best
23.11
4.8
7.9
10.7
7.1
11.4
13.9
10.8
13.4
21.1
14.3
22.4
27.8
16.7
24.4
35.8
21.1
32.2
45.0
27.2
44.3
54.7
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
947.06
1233.80
Best
0.06%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
809.32
604.12
819.25
916.58
724.04
889.40
1034.51
747.46
949.73
1234.58
Avg
With SC
Table 13: Own results: A instances, 50 000 iterations, part 1/2
0.07%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.93
498.41
686.75
809.28
604.19
819.25
917.79
724.04
889.40
1034.17
747.46
950.39
1234.61
Avg
With SC
ALNS-k=2
26.59
4.8
7.9
10.7
7.1
11.4
14.0
10.8
13.5
21.9
14.4
23.1
29.4
16.9
25.3
38.6
21.7
33.1
53.9
27.9
55.1
95.1
Time
0.18%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
812.54
604.12
820.40
918.79
724.04
892.85
1038.04
749.04
953.42
1239.03
0.28%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.61
498.41
686.63
813.28
604.41
820.84
921.85
724.39
895.00
1038.37
752.14
955.84
1241.83
Avg
Without SC
Best
23.12
4.8
7.9
10.8
7.0
11.2
13.7
10.2
13.2
20.8
14.1
22.3
27.8
17.0
24.5
35.2
20.8
32.0
44.7
26.8
45.5
56.8
Time
0.04%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
917.19
724.04
889.12
1033.37
747.46
949.96
1232.48
Best
ALNS-k=3
0.07%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.93
498.41
686.63
809.25
604.12
819.25
918.17
724.04
889.40
1034.25
747.71
950.48
1235.13
Avg
With SC
28.07
4.8
7.9
10.8
7.0
11.2
13.8
10.2
13.3
21.7
14.2
23.0
29.3
17.2
25.3
38.9
21.3
32.9
51.6
27.7
62.3
121.8
Time
28
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.11%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
810.29
604.12
819.25
918.19
724.04
889.58
1036.48
751.35
949.47
1235.51
0.23%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.28
498.41
686.63
812.01
604.19
820.57
921.75
724.04
892.99
1037.61
752.95
952.84
1239.09
Avg
Without SC
Best
24.32
4.6
7.9
11.0
7.0
11.4
14.2
10.3
13.4
21.8
14.7
23.8
29.8
17.3
25.9
39.1
21.6
32.8
47.5
28.7
48.6
59.6
Time
0.03%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.90
724.04
889.12
1033.37
747.46
947.51
1232.87
Best
ALNS-k=4
27.66
4.6
7.9
11.0
7.0
11.5
14.3
10.4
13.4
22.6
14.7
24.5
31.1
17.5
26.7
42.2
22.2
33.7
52.6
29.5
61.6
98.7
Time
0.14%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
810.37
604.12
819.25
916.72
724.04
890.58
1036.06
751.76
953.57
1236.92
0.26%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.81
498.41
686.63
812.35
604.27
820.78
920.11
725.14
893.69
1038.60
752.92
955.33
1241.87
Avg
Without SC
Best
25.51
4.6
7.9
10.6
7.0
11.3
14.3
10.3
13.8
23.0
14.8
24.1
30.9
17.6
27.4
41.1
21.9
34.7
51.8
30.1
51.7
65.9
Time
0.03%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.48
604.12
819.25
916.05
724.04
889.12
1033.43
747.46
948.25
1232.70
Best
0.06%
295.19
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.93
498.41
686.63
809.63
604.12
819.25
917.55
724.04
889.30
1034.24
747.46
949.80
1233.71
Avg
With SC
Table 14: Own results: A instances, 50 000 iterations, part 2/2
0.05%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.93
498.41
686.63
809.03
604.12
819.25
917.58
724.04
889.21
1034.19
747.46
948.94
1234.03
Avg
With SC
ALNS-k=5
28.78
4.6
7.9
10.6
7.0
11.3
14.5
10.4
13.9
23.7
14.9
24.7
32.4
17.8
28.2
44.2
22.5
35.5
57.2
30.9
63.5
104.5
Time
0.15%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
810.91
604.12
820.34
920.39
724.04
889.58
1034.83
750.41
952.47
1239.90
0.27%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.56
498.41
686.63
812.92
604.30
821.30
922.40
725.02
892.27
1038.30
752.86
954.35
1241.15
Avg
Without SC
Best
28.04
4.6
7.6
10.6
7.0
11.6
14.5
10.8
13.9
25.9
15.0
26.3
35.0
18.5
30.6
47.5
23.5
37.8
57.2
32.5
60.5
74.5
Time
0.03%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.90
724.04
889.12
1033.37
747.46
948.25
1231.43
Best
ALNS-k=6
0.06%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.09
498.41
686.63
809.14
604.12
819.25
918.18
724.04
889.21
1034.36
747.71
950.15
1233.36
Avg
With SC
32.61
4.6
7.6
10.6
7.1
11.6
14.7
10.9
14.0
26.6
15.1
26.8
36.4
18.7
31.4
50.9
24.0
38.6
64.0
33.4
76.1
133.7
Time
29
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.13%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
809.69
604.12
820.45
919.99
724.04
890.04
1036.09
750.25
951.47
1234.94
0.22%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.20
498.41
686.63
812.23
604.20
821.51
921.10
724.06
894.02
1036.96
751.83
953.50
1237.99
Avg
Without SC
Best
33.08
7.2
12.0
16.1
10.6
16.4
20.7
15.8
19.9
29.5
21.6
32.9
40.1
25.1
35.3
51.1
30.2
45.5
62.4
38.0
60.5
77.9
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.38
724.04
889.12
1033.37
747.46
947.73
1232.06
Best
ALNS-k=1
37.49
7.2
12.0
16.1
10.7
16.4
20.9
15.8
20.1
30.8
21.8
34.1
42.4
25.5
36.9
56.8
30.9
46.9
70.8
39.1
90.9
110.9
Time
0.10%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.84
604.12
819.25
918.78
724.04
889.58
1036.93
747.46
953.79
1235.03
0.20%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.69
498.41
686.63
811.26
604.12
819.94
920.65
724.37
892.92
1038.00
750.73
954.90
1237.51
Avg
Without SC
Best
33.99
7.1
11.5
16.1
10.6
17.1
20.8
15.5
20.0
30.9
21.6
33.2
41.1
25.0
36.1
52.3
30.6
46.2
65.9
39.9
65.3
80.0
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
946.73
1232.33
Best
0.04%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.72
604.12
819.25
917.41
724.04
889.30
1033.41
747.71
949.52
1232.72
Avg
With SC
Table 15: Own results: A instances, 75 000 iterations, part 1/2
0.04%
295.00
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.83
604.12
819.25
917.16
724.04
889.21
1034.04
747.46
949.11
1232.77
Avg
With SC
ALNS-k=2
37.41
7.1
11.5
16.1
10.6
17.1
21.0
15.5
20.1
32.1
21.7
34.1
43.3
25.3
37.3
56.6
31.2
47.3
72.4
41.0
91.1
102.9
Time
0.11%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.37
498.41
686.63
808.89
604.12
820.30
918.19
724.04
891.86
1034.63
749.04
951.17
1235.95
0.21%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.62
498.41
686.63
811.18
604.27
821.68
921.69
724.05
892.79
1036.13
751.64
953.44
1238.01
Avg
Without SC
Best
34.34
7.0
12.0
16.1
10.6
16.7
20.7
15.4
19.5
31.2
21.4
33.0
40.7
25.3
36.3
52.5
30.0
45.3
65.3
40.0
67.7
87.0
Time
0.01%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
917.35
724.04
889.12
1033.37
747.46
946.06
1230.27
Best
ALNS-k=3
0.04%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.80
604.12
819.25
917.87
724.04
889.12
1033.67
747.76
947.86
1233.07
Avg
With SC
39.09
7.0
12.0
16.1
10.6
16.7
20.9
15.5
19.5
32.3
21.5
33.7
42.6
25.5
37.4
58.3
30.6
46.3
71.7
41.2
85.9
143.5
Time
30
Avg
a2-16
a2-20
a2-24
a3-24
a3-30
a3-36
a4-32
a4-40
a4-48
a5-40
a5-50
a5-60
a6-48
a6-60
a6-72
a7-56
a7-70
a7-84
a8-64
a8-80
a8-96
Instance
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.05
724.04
889.12
1033.37
747.46
945.73
1229.66
Opt
0.13%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
810.62
604.12
819.25
917.66
724.04
892.32
1036.11
750.63
950.68
1237.77
0.22%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.39
498.41
686.63
811.86
604.19
820.96
920.43
724.44
893.54
1036.85
751.75
954.25
1238.79
Avg
Without SC
Best
35.59
6.9
11.7
16.1
10.6
16.9
20.5
15.3
19.8
32.1
21.4
34.3
43.2
25.4
37.6
56.2
31.6
48.1
70.9
41.6
72.4
86.1
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.38
724.04
889.12
1034.05
747.46
946.73
1231.06
Best
ALNS-k=4
40.13
7.0
11.7
16.1
10.6
16.9
20.7
15.3
19.9
33.2
21.5
35.2
45.2
25.7
38.7
61.4
32.3
49.3
79.0
42.7
95.0
132.2
Time
0.12%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
820.40
919.27
724.04
889.12
1035.01
752.60
950.79
1237.00
0.24%
294.63
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.57
498.41
686.63
811.22
604.27
821.73
921.16
724.21
892.67
1038.21
753.19
954.56
1239.53
Avg
Without SC
Best
37.92
6.9
11.7
15.9
10.6
17.1
21.4
15.4
20.7
34.8
22.1
36.6
46.6
25.5
39.9
61.9
32.8
51.1
74.6
44.1
76.9
98.6
Time
0.02%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.38
724.04
889.12
1033.37
747.46
947.59
1231.75
Best
0.05%
294.63
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.52
604.12
819.25
917.34
724.04
889.30
1034.20
747.71
949.76
1233.25
Avg
With SC
Table 16: Own results: A instances, 75 000 iterations, part 2/2
0.05%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
917.52
724.04
889.12
1034.59
747.95
949.74
1232.92
Avg
With SC
ALNS-k=5
43.57
6.9
11.7
15.9
10.6
17.1
21.6
15.5
20.8
35.8
22.1
37.5
48.3
25.7
41.0
68.4
33.5
52.3
86.7
45.2
102.3
159.4
Time
0.14%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
669.37
498.41
686.63
809.98
604.12
820.34
920.58
724.04
890.10
1035.62
749.99
950.73
1238.07
0.24%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
670.03
498.41
686.63
812.15
604.12
820.79
922.79
724.78
894.39
1037.17
751.59
953.62
1238.95
Avg
Without SC
Best
41.66
7.0
11.5
16.2
10.6
17.0
21.6
15.6
20.5
38.3
22.5
38.9
51.1
27.5
45.4
71.5
35.6
57.0
86.3
47.8
88.6
109.7
Time
0.03%
294.25
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.42
604.12
819.25
916.38
724.04
889.12
1033.37
747.46
948.25
1233.24
Best
ALNS-k=6
0.05%
294.82
344.83
431.12
344.83
494.85
583.19
485.50
557.69
668.82
498.41
686.63
808.67
604.12
819.25
917.64
724.04
889.12
1033.90
747.46
949.41
1233.89
Avg
With SC
47.38
7.0
11.5
16.2
10.6
17.0
21.7
15.6
20.5
39.4
22.6
39.6
53.0
27.7
46.7
77.4
36.3
58.2
93.5
48.7
123.1
168.3
Time
31
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.13%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.28
613.73
763.51
903.90
714.83
860.92
981.09
823.97
916.13
1207.44
841.18
1038.22
1193.52
0.28%
309.41
333.54
444.71
394.51
531.73
603.79
494.82
657.02
674.87
614.01
765.30
907.02
715.11
863.31
982.29
826.45
917.54
1214.98
841.52
1040.27
1194.81
Avg
Without SC
Best
8.49
2.1
2.9
4.2
2.8
4.0
5.7
3.5
5.5
7.9
5.2
7.4
10.5
6.0
9.6
13.2
7.7
11.7
16.6
9.4
14.8
21.1
Time
0.03%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.01
902.41
714.83
860.07
978.47
823.97
912.62
1204.99
839.94
1036.34
1189.65
Best
25 000 iter
11.28
2.1
2.9
4.2
2.8
4.0
5.7
3.6
6.0
8.6
5.4
8.3
15.8
6.3
10.7
18.6
10.1
17.8
23.9
12.1
17.9
40.8
Time
0.12%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.88
903.25
714.83
860.27
980.80
823.97
915.46
1211.26
840.63
1039.92
1189.50
0.22%
309.45
333.54
444.71
394.51
531.64
603.79
494.82
656.65
674.36
613.76
763.98
904.80
714.98
860.69
981.83
826.34
916.25
1214.01
841.31
1041.40
1193.23
Avg
Without SC
Best
16.55
4.1
5.9
8.4
5.3
7.8
11.3
7.0
10.7
15.7
10.0
14.3
20.3
11.7
19.2
26.2
15.0
23.1
32.2
18.5
28.3
40.0
Time
0.03%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.01
902.04
714.83
860.07
978.47
823.97
913.30
1206.97
839.89
1036.47
1187.85
Best
0.07%
309.45
333.54
444.71
394.51
531.54
603.79
494.82
656.63
673.93
613.72
762.01
902.24
714.83
860.07
979.39
824.23
913.42
1208.97
840.20
1036.52
1189.29
Avg
With SC
Table 17: Own results: B instances, No Balas-Simonetti
0.10%
309.41
333.54
444.71
394.51
531.63
603.79
494.82
656.67
674.33
613.72
762.58
903.61
714.83
860.38
979.91
824.30
913.40
1209.71
840.31
1036.75
1190.65
Avg
With SC
50 000 iter
22.00
4.1
5.9
8.4
5.4
7.9
11.4
7.1
11.5
16.9
10.4
15.7
27.7
12.2
21.3
39.1
20.1
30.8
46.9
22.3
35.1
83.8
Time
0.06%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.69
714.83
860.65
978.96
824.11
913.31
1207.16
839.94
1037.04
1192.93
0.17%
309.41
332.94
444.71
394.51
531.54
603.79
494.82
656.65
674.64
613.75
763.02
903.79
714.90
860.90
981.57
824.30
915.63
1210.79
840.99
1040.17
1195.04
Avg
Without SC
Best
25.24
6.1
8.7
12.4
8.0
11.7
17.1
10.3
16.3
23.3
15.3
21.9
31.0
17.4
28.8
39.5
22.9
35.1
49.9
28.1
44.1
62.9
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.11
839.89
1036.34
1187.64
Best
75 000 iter
0.05%
309.41
332.94
444.71
394.51
531.54
603.79
494.82
656.63
674.07
613.72
761.52
902.38
714.83
860.07
979.07
823.97
912.77
1204.97
840.03
1036.47
1192.16
Avg
With SC
34.46
6.1
8.7
12.4
8.1
11.8
17.2
10.5
17.3
25.2
15.8
24.1
41.1
18.3
32.1
60.5
27.6
45.3
64.7
34.9
55.0
158.5
Time
32
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.09%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.82
904.89
714.89
860.92
978.47
825.13
912.91
1206.77
840.70
1037.04
1191.34
0.26%
309.41
332.94
444.71
394.51
531.73
603.79
494.82
656.82
674.99
613.98
764.71
906.96
715.24
861.55
980.39
827.06
917.17
1215.87
842.59
1040.20
1194.33
Avg
Without SC
Best
10.55
2.6
3.7
4.9
3.5
5.0
7.2
4.5
7.1
9.8
6.5
9.3
12.8
7.5
11.9
16.3
9.9
14.5
20.7
11.9
17.9
26.0
Time
0.03%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.52
714.83
860.07
978.47
824.11
912.86
1206.57
840.47
1036.34
1188.33
Best
ALNS-k=1
13.52
2.6
3.7
4.9
3.5
5.1
7.2
4.5
7.4
10.4
6.6
9.9
15.2
7.8
12.5
18.8
11.5
18.9
29.6
14.6
20.0
58.3
Time
0.11%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.11
613.73
762.88
903.09
714.83
861.36
979.49
826.49
913.06
1208.45
840.63
1037.98
1192.63
0.26%
309.41
332.94
444.71
394.51
531.63
603.79
494.82
656.87
674.99
614.18
764.73
905.33
715.38
862.76
981.47
827.78
917.58
1214.99
840.95
1039.40
1196.27
Avg
Without SC
Best
11.12
2.6
3.7
5.1
3.5
5.0
7.1
4.5
7.3
10.6
6.8
9.8
13.9
8.1
12.4
17.4
10.6
15.3
22.8
12.2
18.5
27.8
Time
0.04%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.98
613.72
762.01
902.04
714.83
860.07
978.47
824.11
912.87
1208.42
839.94
1036.47
1189.18
Best
0.09%
309.41
332.94
444.71
394.51
531.63
603.79
494.82
656.65
674.21
613.72
762.47
902.75
714.83
860.30
979.45
824.40
913.36
1210.63
840.21
1036.64
1191.19
Avg
With SC
Table 18: Own results: B instances, 25 000 iterations, part 1/2
0.09%
309.41
332.94
444.71
394.51
531.73
603.79
494.82
656.63
674.32
613.72
762.16
903.13
714.83
860.11
979.51
824.82
913.45
1208.75
840.61
1036.70
1192.36
Avg
With SC
ALNS-k=2
14.06
2.6
3.7
5.1
3.5
5.0
7.1
4.5
7.6
11.0
6.9
10.4
17.1
8.3
13.0
21.2
12.7
19.7
28.8
13.1
20.4
62.1
Time
0.10%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.98
613.72
762.13
902.60
714.83
861.06
978.97
824.27
914.93
1210.20
840.63
1039.60
1191.06
0.23%
309.41
332.94
444.71
394.51
531.59
603.79
494.82
657.31
674.74
614.07
764.45
905.24
714.96
862.53
980.97
825.93
916.84
1213.62
841.99
1041.53
1193.37
Avg
Without SC
Best
11.48
2.7
3.6
5.1
3.6
4.9
7.3
4.5
7.5
10.6
6.7
9.9
15.2
8.1
12.8
18.4
11.0
15.1
23.7
12.8
19.3
29.5
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
913.00
1206.03
839.94
1036.47
1188.05
Best
ALNS-k=3
0.09%
309.41
332.94
444.71
394.51
531.54
603.79
494.82
656.77
674.22
613.72
761.91
902.37
714.83
860.68
979.45
824.66
914.05
1208.61
840.62
1036.80
1190.91
Avg
With SC
13.73
2.7
3.6
5.1
3.7
5.0
7.3
4.6
7.8
11.1
6.8
10.5
17.1
8.4
13.4
22.2
12.4
19.4
27.9
15.9
21.4
50.9
Time
33
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.12%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.34
904.32
714.83
860.74
980.76
823.97
916.36
1204.13
840.63
1041.19
1193.32
0.27%
309.41
332.94
444.83
394.51
531.69
603.79
494.82
656.65
674.97
614.07
764.47
906.48
714.94
863.23
982.56
826.44
917.69
1213.24
841.72
1042.71
1194.94
Avg
Without SC
Best
12.21
2.7
3.6
5.0
3.5
5.2
7.2
4.5
8.0
11.4
7.0
10.4
16.0
8.3
13.3
20.0
11.8
16.2
26.5
13.6
20.4
32.3
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.98
823.97
913.06
1204.11
839.89
1036.58
1189.19
Best
ALNS-k=4
14.64
2.7
3.6
5.0
3.5
5.2
7.2
4.5
8.3
11.9
7.2
10.9
18.2
8.5
14.0
24.5
13.8
22.1
31.5
15.3
22.8
54.7
Time
0.12%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.40
613.73
762.84
903.25
714.83
860.61
979.85
824.11
917.15
1210.86
840.87
1039.09
1189.15
0.25%
309.41
332.94
444.83
394.51
531.59
603.79
494.82
656.92
674.99
613.73
764.13
905.17
715.06
861.90
982.08
826.96
918.17
1214.87
841.63
1040.35
1194.31
Avg
Without SC
Best
13.45
2.8
3.7
5.2
3.6
5.3
7.3
4.8
8.5
12.8
7.5
11.2
17.7
9.0
14.8
22.1
13.2
18.3
30.0
15.1
22.6
36.3
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.67
1205.34
839.89
1036.47
1188.48
Best
0.09%
309.41
332.94
444.83
394.51
531.54
603.79
494.82
656.63
674.30
613.72
761.79
902.84
714.83
860.27
979.78
824.44
913.35
1210.96
840.17
1036.89
1191.38
Avg
With SC
Table 19: Own results: B instances, 25 000 iterations, part 2/2
0.08%
309.41
332.94
444.83
394.51
531.63
603.79
494.82
656.65
674.25
613.72
762.00
902.92
714.83
860.38
979.51
824.22
913.64
1208.11
840.16
1036.89
1191.28
Avg
With SC
ALNS-k=5
16.13
2.8
3.7
5.3
3.6
5.4
7.3
4.8
8.8
13.3
7.6
11.6
20.3
9.2
15.4
26.0
15.8
23.7
36.8
17.1
24.5
62.4
Time
0.11%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
761.40
903.63
714.83
860.61
980.86
824.68
914.93
1208.10
841.10
1037.96
1194.66
0.28%
309.41
333.54
444.71
394.51
531.54
604.13
494.82
656.78
674.45
614.07
763.63
905.88
714.84
862.30
981.00
827.54
916.88
1216.24
841.64
1042.99
1196.92
Avg
Without SC
Best
15.76
2.7
3.6
5.3
3.7
5.3
7.4
5.0
10.1
14.9
8.0
13.1
21.7
9.7
17.4
26.6
16.3
20.7
38.0
17.2
26.2
44.9
Time
0.03%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.53
714.83
860.07
979.01
824.11
913.31
1206.00
839.89
1036.47
1188.60
Best
ALNS-k=6
0.11%
309.41
333.54
444.71
394.51
531.54
604.10
494.82
656.65
674.06
613.72
761.98
903.83
714.83
860.23
979.49
824.57
913.75
1210.43
840.34
1036.68
1192.23
Avg
With SC
19.89
2.7
3.6
5.3
3.7
5.4
7.4
5.0
10.4
15.3
8.1
13.6
25.3
9.9
18.1
29.4
18.7
24.8
50.0
19.4
28.8
95.5
Time
34
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.10%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
674.40
613.73
762.13
902.04
714.83
860.74
979.41
824.11
915.50
1209.41
840.63
1037.73
1192.08
0.20%
309.41
332.64
444.71
394.51
531.54
603.79
494.82
656.63
674.81
613.82
763.04
904.36
714.83
861.29
981.23
826.98
917.21
1212.53
841.44
1039.63
1194.83
Avg
Without SC
Best
21.39
5.2
7.2
9.7
7.1
10.1
14.5
8.9
14.0
19.8
13.3
18.5
25.7
15.5
24.2
33.3
19.8
28.8
42.9
24.9
36.5
53.0
Time
0.03%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1206.21
839.89
1036.34
1188.79
Best
ALNS-k=1
26.77
5.2
7.2
9.8
7.1
10.1
14.5
9.0
14.7
20.8
13.5
19.5
31.2
15.9
25.4
41.3
23.5
36.8
53.7
27.4
40.5
113.5
Time
0.10%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
762.34
902.04
714.83
860.27
979.47
824.21
913.98
1209.60
841.03
1038.79
1193.84
0.20%
309.41
332.94
444.71
394.51
531.73
603.79
494.82
656.70
674.35
613.81
763.49
904.73
714.84
862.12
980.94
826.44
916.25
1212.10
841.13
1040.29
1195.21
Avg
Without SC
Best
22.41
5.2
7.2
9.9
7.1
10.2
14.6
9.0
14.5
20.7
13.4
19.0
27.9
15.9
24.6
35.8
20.6
30.2
47.0
25.2
38.3
57.0
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.01
902.04
714.83
860.07
978.47
823.97
912.62
1206.31
839.89
1036.34
1187.21
Best
0.06%
309.41
332.94
444.71
394.51
531.73
603.79
494.82
656.63
673.99
613.72
762.19
902.38
714.83
860.22
978.91
824.23
913.20
1208.90
840.16
1036.54
1188.51
Avg
With SC
Table 20: Own results: B instances, 50 000 iterations, part 1/2
0.06%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.97
613.72
761.91
902.37
714.83
860.07
979.28
824.20
913.07
1208.46
840.16
1036.63
1189.61
Avg
With SC
ALNS-k=2
26.51
5.2
7.2
9.9
7.1
10.2
14.7
9.1
15.0
21.4
13.6
20.0
32.7
16.3
25.7
43.5
24.1
38.0
55.2
28.7
41.9
95.8
Time
0.10%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
762.34
902.04
714.83
860.74
978.47
823.97
915.59
1210.08
840.63
1036.81
1193.81
0.22%
309.41
333.54
444.83
394.51
531.78
603.79
494.82
656.85
674.51
613.73
763.53
905.25
714.84
863.33
980.13
824.36
916.86
1213.69
841.06
1038.95
1196.16
Avg
Without SC
Best
22.63
5.3
7.1
9.9
6.8
9.9
14.5
9.0
14.9
21.4
13.4
20.0
29.0
15.7
25.0
36.5
21.4
29.9
46.0
25.0
37.9
59.2
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.86
839.89
1036.34
1189.27
Best
ALNS-k=3
0.07%
309.41
333.54
444.83
394.51
531.63
603.79
494.82
656.63
674.06
613.72
761.83
902.30
714.83
860.35
978.73
824.06
913.16
1205.39
840.15
1036.53
1191.66
Avg
With SC
28.24
5.3
7.1
9.9
6.8
9.9
14.5
9.1
15.4
22.3
13.5
20.8
34.6
16.1
26.0
43.0
23.9
37.1
52.3
28.9
41.7
131.9
Time
35
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.08%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
762.34
902.04
714.83
860.27
978.47
823.97
914.93
1210.17
840.64
1037.47
1190.25
0.20%
309.41
333.24
444.71
394.51
531.54
604.13
494.82
656.65
674.56
613.80
763.12
904.16
714.92
860.96
980.43
825.93
916.87
1214.33
841.51
1039.26
1193.53
Avg
Without SC
Best
23.66
5.6
7.2
9.9
7.0
10.1
14.2
9.0
15.6
22.6
13.8
20.7
30.6
16.5
25.7
38.3
22.6
31.1
51.0
26.3
39.7
61.3
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.96
839.89
1036.34
1186.66
Best
ALNS-k=4
27.48
5.6
7.2
9.9
7.1
10.1
14.2
9.1
16.1
23.4
14.0
21.6
35.0
16.9
26.7
45.3
26.5
38.1
66.2
30.4
43.2
88.5
Time
0.09%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
762.88
902.60
714.83
860.74
979.21
824.27
913.31
1209.00
840.63
1038.53
1192.39
0.20%
309.41
333.54
444.71
394.51
531.54
603.79
494.82
656.67
674.32
613.73
763.71
903.84
714.90
862.35
979.85
825.67
916.66
1211.96
841.46
1040.36
1195.00
Avg
Without SC
Best
25.60
5.3
7.3
10.1
7.2
10.2
14.6
9.0
16.4
24.8
14.3
21.8
33.8
17.0
27.5
42.8
25.8
33.9
56.0
27.9
42.4
69.2
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.11
839.89
1036.34
1187.39
Best
0.06%
309.41
333.54
444.71
394.51
531.54
603.79
494.82
656.63
673.93
613.72
761.79
902.26
714.83
860.18
979.02
824.14
913.18
1206.29
839.93
1036.53
1190.44
Avg
With SC
Table 21: Own results: B instances, 50 000 iterations, part 2/2
0.05%
309.41
333.24
444.71
394.51
531.54
603.79
494.82
656.63
673.92
613.72
761.88
902.13
714.83
860.11
978.83
824.18
913.08
1207.15
840.04
1036.50
1188.47
Avg
With SC
ALNS-k=5
30.43
5.3
7.3
10.1
7.2
10.2
14.6
9.1
16.9
25.7
14.5
22.6
39.1
17.3
28.5
49.7
29.5
40.0
64.2
32.0
45.5
124.6
Time
0.06%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
762.34
902.04
714.83
860.61
978.47
824.27
913.00
1205.57
839.89
1037.30
1192.60
0.19%
309.41
333.54
444.71
394.51
531.55
603.79
494.82
657.00
675.01
613.88
763.17
904.17
714.94
861.05
979.81
825.28
915.98
1211.99
840.64
1038.79
1196.22
Avg
Without SC
Best
28.90
5.6
7.1
10.2
7.1
10.2
14.7
9.2
18.4
28.2
15.1
24.3
39.5
18.2
30.6
48.8
29.2
37.9
67.1
31.8
48.7
81.6
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.01
902.04
714.83
860.07
978.47
823.97
912.62
1204.25
839.89
1036.34
1188.70
Best
ALNS-k=6
0.07%
309.41
333.54
444.71
394.51
531.45
603.79
494.82
656.63
674.06
613.72
762.03
902.38
714.83
860.07
978.80
824.16
913.12
1207.60
839.92
1036.42
1190.27
Avg
With SC
34.64
5.6
7.1
10.2
7.1
10.2
14.7
9.3
18.9
29.0
15.2
25.2
44.2
18.5
31.5
54.6
31.9
44.5
77.9
35.4
52.4
155.0
Time
36
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.09%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.52
714.83
860.47
978.96
823.97
914.57
1210.64
840.63
1038.93
1191.22
0.17%
309.41
333.54
444.71
394.51
531.45
603.79
494.82
656.65
674.13
613.79
762.43
903.32
714.92
860.75
979.91
824.53
917.06
1212.67
841.09
1040.12
1193.23
Avg
Without SC
Best
31.73
8.0
10.7
14.9
10.6
14.7
21.8
13.6
21.3
30.2
20.2
27.2
38.8
23.0
35.9
49.1
29.3
42.5
62.7
35.4
53.1
79.5
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.86
1204.11
839.89
1036.34
1185.82
Best
ALNS-k=1
37.37
8.0
10.7
15.0
10.6
14.7
21.9
13.6
22.1
31.4
20.5
28.5
46.6
23.5
37.5
59.0
33.7
54.1
71.3
40.2
59.6
132.8
Time
0.11%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.01
903.07
714.83
860.72
978.97
824.11
914.45
1214.70
839.89
1038.17
1192.64
0.19%
309.41
333.24
444.73
394.51
531.63
603.79
494.82
656.67
674.71
613.75
762.72
903.44
714.85
861.10
981.21
824.33
916.62
1216.74
840.62
1039.61
1195.11
Avg
Without SC
Best
33.23
7.8
10.8
14.8
10.5
14.9
22.1
13.6
21.8
31.4
20.6
28.1
42.3
23.1
37.1
54.4
30.9
43.9
66.6
36.9
55.2
85.5
Time
0.02%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1205.82
839.89
1036.34
1188.07
Best
0.06%
309.41
333.24
444.73
394.51
531.63
603.79
494.82
656.65
674.09
613.72
761.76
902.70
714.83
860.07
978.82
824.08
912.90
1208.04
839.90
1036.39
1189.73
Avg
With SC
Table 22: Own results: B instances, 75 000 iterations, part 1/2
0.04%
309.41
333.54
444.71
394.51
531.45
603.79
494.82
656.63
673.84
613.72
761.76
902.36
714.83
860.07
978.74
823.97
913.08
1205.38
839.90
1036.39
1188.86
Avg
With SC
ALNS-k=2
40.36
7.8
10.8
14.8
10.6
15.0
22.2
13.6
22.5
32.6
20.8
29.3
51.2
23.6
38.5
67.0
33.9
50.9
87.9
39.7
60.3
161.9
Time
0.09%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.73
761.40
902.04
714.83
860.63
979.65
823.97
913.56
1212.33
840.64
1037.22
1191.57
0.19%
309.41
333.84
444.71
394.51
531.54
603.79
494.82
656.63
674.10
613.73
762.86
903.40
714.83
860.74
980.50
825.63
915.87
1213.65
841.07
1039.54
1195.36
Avg
Without SC
Best
33.14
8.0
10.8
14.7
10.4
15.1
21.2
13.6
22.0
32.0
20.2
28.7
42.6
23.1
36.6
52.8
31.9
44.6
67.7
36.7
54.4
83.7
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.57
839.89
1036.34
1187.82
Best
ALNS-k=3
0.06%
309.41
333.84
444.71
394.51
531.54
603.79
494.82
656.63
673.81
613.72
761.64
902.04
714.83
860.07
978.78
824.16
912.97
1205.98
840.05
1036.39
1190.41
Avg
With SC
40.61
8.0
10.8
14.7
10.4
15.1
21.2
13.6
22.7
33.0
20.4
29.8
49.7
23.6
38.0
64.2
36.3
52.9
83.6
41.7
58.9
171.6
Time
37
Avg
b2-16
b2-20
b2-24
b3-24
b3-30
b3-36
b4-32
b4-40
b4-48
b5-40
b5-50
b5-60
b6-48
b6-60
b6-72
b7-56
b7-70
b7-84
b8-64
b8-80
b8-96
Instance
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1203.37
839.89
1036.34
1185.55
Opt
0.08%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
861.15
979.30
824.11
914.33
1211.05
839.89
1037.47
1190.50
0.17%
309.41
333.24
444.71
394.51
531.45
603.79
494.82
656.82
674.54
613.73
762.94
903.53
714.83
862.36
980.62
824.44
915.87
1214.04
840.69
1039.84
1192.18
Avg
Without SC
Best
35.06
8.1
10.6
15.0
10.5
15.2
21.7
13.6
22.5
33.5
20.6
30.1
44.9
23.9
37.9
56.9
34.3
46.8
73.8
38.4
58.2
92.7
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.50
839.89
1036.34
1186.37
Best
ALNS-k=4
39.68
8.1
10.6
15.1
10.6
15.2
21.8
13.7
23.2
34.7
20.8
31.1
51.1
24.4
39.4
67.6
38.0
54.3
85.7
43.3
63.9
129.1
Time
0.10%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.94
902.04
714.83
860.72
979.80
824.27
913.31
1211.87
840.51
1038.01
1191.48
0.19%
309.41
333.24
444.71
394.51
531.50
603.79
494.82
656.63
674.29
613.80
763.70
904.86
714.84
860.95
980.78
825.18
915.92
1214.86
840.66
1039.24
1193.77
Avg
Without SC
Best
37.65
8.2
10.7
14.9
10.4
15.1
21.4
13.8
24.2
36.9
20.9
31.4
50.5
25.0
41.3
63.1
37.6
50.6
82.6
40.4
61.8
100.4
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1205.07
839.89
1036.34
1186.52
Best
0.04%
309.41
333.24
444.71
394.51
531.45
603.79
494.82
656.63
673.97
613.72
761.52
902.11
714.83
860.07
978.75
824.12
912.69
1206.71
840.16
1036.39
1187.82
Avg
With SC
Table 23: Own results: B instances, 75 000 iterations, part 2/2
0.04%
309.41
333.24
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.52
902.04
714.83
860.19
978.87
824.11
912.89
1206.50
840.14
1036.42
1187.09
Avg
With SC
ALNS-k=5
44.38
8.2
10.7
15.0
10.4
15.2
21.4
13.8
24.9
38.0
21.1
32.3
58.5
25.4
42.8
75.3
42.0
60.4
102.7
44.2
66.5
166.9
Time
0.11%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
762.34
903.49
714.83
860.61
979.62
824.42
915.64
1211.72
840.63
1036.96
1192.06
0.20%
309.41
333.84
444.71
394.51
531.45
603.79
494.82
656.63
674.06
613.73
762.97
905.12
714.83
860.75
980.99
825.80
916.75
1213.13
841.47
1039.04
1195.02
Avg
Without SC
Best
42.54
7.8
11.0
15.1
10.7
15.3
22.0
13.8
27.1
40.9
22.1
35.2
58.3
26.8
43.8
71.1
42.3
55.7
100.1
45.9
71.6
121.9
Time
0.01%
309.41
332.64
444.71
394.51
531.45
603.79
494.82
656.63
673.81
613.72
761.40
902.04
714.83
860.07
978.47
823.97
912.62
1204.47
839.89
1036.34
1186.93
Best
ALNS-k=6
0.05%
309.41
333.84
444.71
394.51
531.45
603.79
494.82
656.63
673.92
613.72
761.52
902.56
714.83
860.07
978.95
824.05
912.94
1205.66
840.01
1036.37
1188.58
Avg
With SC
50.26
7.8
11.0
15.1
10.7
15.3
22.0
13.8
27.8
41.9
22.3
36.2
67.8
27.2
45.0
82.9
46.7
66.9
115.2
52.3
76.6
208.5
Time