A metaheuristic algorithm and structured analysis for the Line-haul Feeder Vehicle Routing Problem with Time Windows

Abstract

Synchronisation in vehicle routing is a rather new field of research and naturally new problems arise. One of these problems is the Line-haul Feeder Vehicle Routing Problem (LFVRP). It uses a fleet of small and large vehicles to serve two types of customers. The first type provides additional parking space and can be visited by both vehicle classes. The second type can only be visited by the small vehicle class as these customers provide only limited parking space. The main characteristic of the small vehicle class is the limited capacity. To overcome this particular disadvantage, the small vehicles can use the large vehicles as virtual depots. In other words, a small and large vehicle can meet at a parking lot or at a customer with enough space (type-1 customer) and perform a transfer of goods. For a successful reloading operation, both vehicles must be present at the same place at the same time. Thus, both vehicle tours must be synchronized. After using the large vehicle as virtual depot, the small vehicle can proceed immediately afterwards because it does not need to go back to the physical depot. Consequently, less time and distance is required which results in a reduction of the overall costs. The advantage of the LFVRP over classical variants of the Vehicle Routing Problem has been shown in previous papers. Yet, customer time windows have been neglected so far and as time windows play an important role in vehicle routing research, they need to be addressed properly. Therefore, we aim to close this gap by introducing the Line-haul Feeder Vehicle Routing Problem with Time Windows (LFVRPTW). We discuss the complexity of customer time windows for the LFVRPTW and adopt the previously introduced algorithm for the LFVRP. Furthermore, we provide a thorough computational analysis on the impact of different time window characteristics and show the advantage of the LFVRPTW over other variants of the Vehicle Routing Problem with Time Windows.

1 Introduction

The digital age provides many new possibilities in city logistics and has already changed our way of life.¹ Nowadays, customers can look-up a large variety of goods on their mobile device and they can place an order whenever they like. Due to the vast amount of data, the customer is provided with all the necessary information of a potential purchase; e.g. pictures, number of available items, storage location, overall costs (purchase and delivery) and estimated delivery time. However, these new possibilities also increase the expectations of the customers. For instance: when ordering food, the customer expects the food to be delivered within minutes. Consequently, these customers are interested in the delivery status, current location and expected delivery time of their goods. In addition to the increased customer expectations, other problems arise as well. According to the United Nations (2014), the population of the major European cities will rise to their limits—population will increase up to 20% and more from 2005 to 2020. This will result in multiple issues like higher demands, increased traffic (especially during rush hour), rising land prices, more congested areas with limited space and many more. Companies specialised in city logistics have to master these challenges to keep their competitive edge. Consequently, new problems arise and one of these problems is the Line-haul Feeder Vehicle Routing Problem (LFVRP).

The LFVRP uses one physical depot (PD) where all vehicles are dispatched. To serve the customers, two classes of vehicles are used—the small (SV) and large (LV) vehicle class. The small vehicle class can be represented by e.g. a car, motorbike or cargo-bike. Yet, cargo-bikes are the preferred choice due to economic and environmental reasons. The costs for a cargo-bike are much less than e.g. a car, they can easily move around in congested areas and they to not have any emissions due to the absence of a combustion engine. However, vehicles with alternative power engines such as electric cars or motorbikes should be considered as well. To sum up, the characteristics of the small vehicle class are limited capacity, limited range and lesser costs. Compared to the small vehicle class, the large vehicle class has hardly any capacity limit (e.g. a truck with a trailer). Furthermore, they can drive longer distances but also have higher overall costs. As for the customers, they are classified according to their availability of parking space. Some customers (type-1) provide enough space and can be visited by both vehicle classes. Yet, the majority of customers (type-2) live in congested areas and are difficult to reach. Hence, only the small vehicle class can be used. Although the manoeuvre possibilities (especially in narrow streets and during rush hour) of the small vehicles are their biggest advantage, the main disadvantage of limited capacity remains. In other words, the small vehicle may only be able to visit a few customers before it must return to the PD. This necessary journey to the PD results in additional travelling costs and wasted time. To solve this issue, the small vehicle can use the large vehicle as a virtual depot (VD). This can happen at a parking place or at a customer with enough parking space (customer of type-1). However, the small and large vehicle need to synchronise their tours to be able to perform a transshipment. In other words, the small and large vehicle need to be at the same place at the same time. Thus, the small vehicle saves time and distance by avoiding travelling back to the PD. Furthermore, the overall costs will further decrease as the required number of small vehicles can be significantly reduced.

Although we extensively investigated the LFVRP in our previous papers, we neglected time windows so far. Our analysis showed that the problem is already very complex even without time windows. Early investigations supported the assumption that synchronisation between vehicles is hardly possible if time windows are in place. However, time windows play an important role in vehicle routing research and therefore need to be addressed accordingly. Therefore, we aim to close this gap by introducing the Line-haul Feeder Vehicle Routing Problem with Time Windows (LFVRPTW).

The contribution of this paper is twofold. First, we introduce time windows and adopt the well performing LFVRP-algorithm to handle time windows for customer service. Second, we analyse different time window categories and provide evidence that the LFVRPTW is still of advantage even with time windows in place. The remainder of this paper is structured as follows. In Sect. 2 we will review the existing literature on the LFVRP(TW) and closely related variants. A structural analysis on the impact of time windows will be given in Sect. 3. Section 4 will provide an overview of the used heuristic and describe each step in more detail. After that, a computational analysis is conducted in Sect. 5 where we will investigate different time window categories over large number of instances and compare our results to the best-known LFVRPTW results. The paper will be concluded with our final remarks in Sect. 6.

2 Literature review

The LFVRPTW is a rather new problem but at its core it is still a Vehicle Routing Problem (VRP). Furthermore, the solution approach features some well investigated and successfully applied heuristics. Therefore, we decided to provide a short yet broad overview of the relevant literature. We start with a generic overview of the VRP and the importance of time windows. Afterwards, we discuss relevant solution heuristics before we focus on relevant literature on the LFVRP(TW). We conclude the literature review by presenting similar problems with a heterogeneous fleet, usage of multiple tours and a specific customer vehicle relationship.

The VRP has been extensively studied over the last half century and is still a prominent topic within operations research. Hence, a vast number of literature on the different variants exist and for a solid overview the interested reader is advised to see Cordeau et al. (2002), Laporte (2009) or Laporte et al. (2014). Time windows play an important role in vehicle routing research and consequently most of the VRP variants have been analysed with time windows. To indicate an analysis with time windows, the suffix TW is usually added to the problem abbreviation (e.g. VRPTW). Time windows are associated with the customers for most VRPTW variants. In other words, the vehicle must arrive in a certain time frame to start the service for the customer. However, other time windows like opening hours of shops, delivery time windows (e.g. before midday or night delivery) or driving bans for trucks due to particulate matter pollution may also be considered. Overall, time windows reduce the degree of freedom and increase the complexity of the VRP itself. If time windows (especially for delivery) are too tight, the effectiveness of the routing will be reduced significantly (see Russo and Comi 2010). An interesting research on the impact of time windows on city logistics applications can be found in Deflorio et al. (2012).

An early yet often used heuristic for handling time windows is the Push-Forward-Insertion-Heuristic (PFIH). It was originally introduced by Solomon (1987) and is an efficient heuristic for inserting a customer into an existing route while preserving time window constraints. Further reading on the PFIH can be found in Thangiah et al. (1993). Furthermore, a thorough survey on the VRPTW for route construction, local search algorithms and metaheuristics is provided in Bräysy and Gendreau (2005a) and Bräysy and Gendreau (2005b).

In early research papers on the VRP and its variants, problem specific heuristics were developed from scratch. These heuristics provided reasonably good results for the problem at hand but often failed if applied to other VRP variants. To overcome this disadvantage, generic solution heuristics—called metaheuristics—were developed and they can be applied to a large number of optimization problems. The most prominent representatives of metaheuristics are Ant Colony Optimization (ACO—e.g. Reimann et al. 2004; Dorigo and Blum 2005), Genetic Algorithms (GA—see Baker and Ayechew 2003; Prins 2004), Greedy Randomized Adaptive Search Procedure (GRASP—compare Feo and Resende 1995; Resende and Ribeiro 2003), Simulated Annealing (SA—e.g. Kirkpatrick et al. 1983; van Breedam 1995), Adaptive Large Neighbourhood Search (ALNS—see Ropke and Pisinger 2006a, b; Pisinger and Ropke 2007, 2010) and Tabu Search (TS—compare Glover 1989, 1990). For a solid overview on metaheuristics the interested reader is advised to see Gendreau et al. (2008) or Laporte (2009).

Although the CPU performance of modern computers is improved rapidly, the optimal VRP solution for large scaled problem sizes can hardly be found within a reasonable amount of time. Remark: the VRP and its variants are np-hard. However, for smaller scaled problem sizes the optimal solution can be found by the use of a mathematical problem solver. Thus, hybrid algorithms are developed where large sized problems are partially solved to optimality. This research field is known as matheuristics in the literature and the interested reader is advised to see Boschetti et al. (2009), Doerner and Schmid (2010), Subramanian et al. (2012) and Archetti and Speranza (2014).

The LFVRP originated from Asia/Taiwan and occurred during the delivery of lunch boxes. It was first introduced as the LFVRP with Virtual Depots (LFVRPVD) by Chen et al. (2011b). They proposed two simple heuristics and examined them on 17 test instances. In their second paper Chen et al. (2011a), they added time windows (LFVRPVDTW) and introduced a new (two-stage) heuristic which also included a tabu search procedure. Chen and Wang (2012) relaxed some of the limitations made by previous authors and also introduced a new construction heuristic—named the general insertion method—to improve the heuristic even further. For their final paper (see Chen 2015), several issues for the LFVRPTW have been analysed. These issues were different solution algorithms, adjustments to customer demands, number of type-1 customers (VDs) and relaxed time windows.

In Brandstätter and Reimann (2018b) we provided the first mathematical problem formulation for the LFVRP and introduced two new promising heuristics named the Linkage- and Split-Approach. Both heuristics provided significantly better results than the results presented by Chen et al. (2011b). Furthermore, we performed a sensitivity analysis and showed that the LFVRP benefits from a more decentralised depot, larger capacity for the small vehicle class, shorter service/transshipment times and more possibilities for reloading. We further improved the two proposed heuristics in Brandstätter and Reimann (2018a) by combining the advantages of metaheuristics, matheuristics, generating multiple solutions and local search. We were able to realise an improvement of around 9% compared to previous results.

The LFVRP(TW) has some similarities to already existing problems. One similarity is the heterogeneous fleet of vehicles. Most of the VRP(TW) problems assume a homogeneous fleet although a heterogeneous fleet is most often the case in real life applications. A heterogeneous fleet of vehicles has at least two or more vehicle classes which are classified according to certain characteristics (e.g. average speed, costs, capacity). In the literature this problem is often referred to as the Heterogeneous Fleet VRP (HFVRP (TW); compare e.g. Baldacci et al. 2008; Subramanian et al. 2012; Penna et al. 2013; Kritikos and Ioannou 2013; Koç et al. 2016); or in earlier publications as Fleet Size Mix (FSM: see Golden et al. 1984; Liu and Shen 1999).

Another characteristic of the LFVRP(TW) is the possibility of multiple tours per vehicle. In the classical formulation of the VRP(TW), a vehicle is used for a single tour only. However, if the capacity of a vehicle is depleted, it can drive back to the depot for reloading and continue afterwards with another tour. In the literature this problem is often referred as Multi Trip VRP, VRP with multiple routes, VRP with multiple use of vehicles or VRP with Multiple Trips (MTVRP) and a solid overview is provided by Cattaruzza et al. (2014), Cheikh et al. (2015), François et al. (2016) or Cattaruzza et al. (2016).

A rather closely related problem is the Site Dependent Vehicle Routing Problem (SDVRP). In this problem some customers can be only visited by a certain vehicle class. Hence, this problem also uses a heterogeneous fleet of vehicles and has a predefined customer-vehicle relationship. Further reading on the SDVRP can be found in Pisinger and Ropke (2007), Chao et al. (2016) and Cordeau et al. (2016). The main difference between the SDVRP and LFVRP(TW) is the synchronisation possibility. The synchronisation between vehicles is a rather young field of research where the vehicle tours are no longer independent. For example, two vehicles meet and the workers perform a certain task together—e.g. a transshipment of goods or a service/maintenance task where multiple service workers are needed. In recent years multiple problems with synchronisation constraints have been introduced (see Bredström and Rönnqvist 2008; Grangier et al. 2016; Anderluh et al. 2017). A lately conducted survey on vehicle routing problems with synchronisation constraints can be found in Drexl (2012).

3 Structural problem analysis

3.1 Review of previous work without time windows

In Brandstätter and Reimann (2018b) we presented two simple heuristic approaches named the Linkage- and Split-Approach. The basic concept of the Linkage-Approach is to generate feasible small vehicle tours for all type-2 customers and try to link them through a VD (type-1 customer) or the PD. If two tours can be linked through a VD, that VD must also be visited by a large vehicle at the same time to perform a transshipment of goods. Hence, the two tours need to be synchronised. The Split-Approach, on the other hand, generates a giant tour for all type-2 customers and tries to create feasible sub-tours by splitting the giant tour and inserting VDs or the PD into these sub-tours. If VDs are required to create feasible tours, these VDs must also be part of a large vehicle tour - like in the Linkage-Approach. The overall objective is to minimise the total cost consisting of fixed vehicle cost as well as variable fuel and wage costs for drivers.² Both approaches performed well but still had room for improvement. Therefore, we improved both approaches by combining the benefits of metaheuristics, matheuristics, generating multiple solutions and local search. A detailed overview can be found in Brandstätter and Reimann (2018a). Both approaches could be significantly improved, yet the Linkage-Approach outperformed the Split-Approach in every aspect. As a result, we decided to only proceed further with the Linkage-Approach. A detailed description of the different steps for the Linkage-Approach together with a small pseudo code will be provided in Sect. 4. For the following analysis, we will focus on the basic concept of the Linkage-Approach which can be described in four steps.

Step 1::

Create small vehicle tours for all type-2 customers.

Step 2::

Try to link the small vehicle tours through a VD or the PD to reduce the number of vehicles.

Step 3::

Create large vehicle tours with used VDs in chronological order.

Step 4::

Insert all remaining type-1 customers into the existing tours.

3.2 Problem analysis without time windows

Before we start with the problem analysis with time windows, we briefly review the characteristics of the Linkage-Approach without time windows. For a better understanding, we provide a small illustrative example in Fig. 1. The upper part (a) shows the result of the first step: two small vehicle tours with two type-2 customers (circle shape) each and two not yet routed customers of type-1 (diamond shape) which start and end at the depot (square shape with label PD).³ Naturally, both tours start at the beginning of the time horizon as no further time restrictions concerning service exist.

Fig. 1

LFVRP example

As mentioned before, the variable part of the objective function includes the drivers wage. Thus, from a cost perspective it does not matter when the tours start as only the tour durations ($t^{d}$) are taken into account. The tour duration is calculated as tour finish time ($t^{ft}$) minus tour start time ($t^{st}$): $t^{d} = t^{ft}-t^{st}$. Therefore, if for example the starting time of SV Tour 2 is postponed, the cost value will remain the same as the finish time will be postponed as well. If we now proceed with the second step of the Linkage-Approach, these two tours will be linked through a VD. This is possible because the total tour duration of the resulting tour is still within the max. allowed tour duration. Hence, we have to replace the edges $e_{2,PD}$ with $e_{2,VD}$ of SV Tour 1 and $e_{PD,3}$ with $e_{VD,3}$ of SV Tour 2. In other words, customers 3 and 4 will also be served by the same small vehicle but at a later point in time. In our example the two remaining customers of type-1 will be served by the large vehicle (see Fig. 1b).

3.3 Problem analysis with time windows

Time windows represent an important aspect in vehicle routing research but also increase the complexity of the problem. The PFIH (introduced by Solomon 1987 and further described in Thangiah et al. 1993) is an effective heuristic for inserting a customer into an existing tour. However, in the context of the LFVRPTW we focus on moving a whole tour forwards or backwards in time. Therefore, we used the overall idea of the PFIH and adjusted it to our needs. For a better understanding we provide another small illustrative example in Fig. 2. The horizontal axis shows the time horizon whereas the customer numbers are displayed on the vertical axis. For simplification we show only the time window frames of the respective customers (grey areas) and the elapsed time concerning driving and service time. Figure X shows a single small vehicle tour with four customers: $0 \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 4 \rightarrow 0$. The time windows are denoted by ($a_i$) for the earliest starting time and ($b_i$) for the latest starting time of customer i. In other words, if the vehicle arrives ($t^a_i$) within this time frame ($a_i \le t^a_i \le b_i$), the service of this customer can start immediately. Yet, if the vehicle arrives before the time window starts ($t^a_i < a_i$), the vehicle has to wait until the time window opens. In addition, if the vehicle arrives after the time window closes ($b_i < t^a_i$), the customer cannot be served by this vehicle.

Fig. 2

Time windows analysis

Figure 2 shows the small vehicle tour in the context of space and time. The vehicle tour starts at 10 and arrives within the time window of each customer and ends at 120 units. As all arrival times are within the time windows, no waiting times occur. Even the time window of the depot closes 10 units after the vehicle arrives. Hence, that tour can still be moved forwards in time without changing the total costs and also remains feasible. To find out how much the tour can be moved in time, we introduce a new variable called time window flexibility ($\delta ^{+/-}_i$). The time window flexibility ($\delta ^{+}_i$) is calculated as the latest starting time minus the arrival time [see Eq. (1)] and ($\delta ^{-}_i$) as the arrival time minus earliest starting time [see Eq. (2)], respectively. ($\delta ^{+}_i$) denotes a move forwards and ($\delta ^{-}_i$) backwards in time and S the set of nodes/customers visited by the vehicle.

$$\begin{aligned}&\displaystyle \delta ^{+}_i = b_i - t^a_i \end{aligned}$$

(1)

$$\begin{aligned}&\displaystyle \delta ^{-}_i = {\left\{ \begin{array}{ll} t^a_i - a_i &{}\displaystyle \quad \text {if}\quad t^a_i > a_i \\ 0 &{}\displaystyle \quad \text {else} \end{array}\right. } \end{aligned}$$

(2)

$$\begin{aligned}&\displaystyle \begin{aligned}&\displaystyle \varDelta ^{+/-}_{max}=min(\delta ^{+/-}_0,\ldots ,\delta ^{+/-}_i) \\&\displaystyle \quad \forall i \in S \text { and } S = \{0,\ldots ,n\} \end{aligned} \end{aligned}$$

(3)

As we can see in Fig. 2, some customers have larger ($\delta ^{+/-}_i$) values than others. Thus, we have to find the minimum ($\delta ^{+/-}_i$) to know the maximum amount of time ($\varDelta ^{+/-}_{max}$) our tour can be moved forwards or backwards in time [see Eq. (3)]. In our example, the smallest ($\delta ^{+}_i$) is found at customer 4 with $(\varDelta ^{+}_{max} = 5 \text { units})$ and ($\delta ^{-}_i$) at customer 2 with $(\varDelta ^{-}_{max} = 5 \text { units})$.

If we use our first example again, but with time windows, we get the following situation: In Fig. 3 two possible scenarios are presented. Two small vehicle tours are positioned according to their chronological sequence and two customers of type-1 are not yet assigned. Customers in Fig. 3a have very close time windows (see customer 2 and 3), whereas the time windows in Fig. 3b are further apart. Furthermore, we assume that ($\varDelta ^{+/-}_{max} = 0$), which means no further service postponement is possible. Consequently, if we further proceed with the Linkage-Approach we have two different outcomes. Due to the time window restriction, the LFVRPTW algorithm is able to reduce the number of small vehicles by linking the two small vehicle tours in example (b). In example (a) it is not possible to link the small vehicle tours together as customers 2 and 3 are required to be serviced at the same time. Overall, the solution in example (a) requires three small vehicles compared to example (b) with only one small and one large vehicle.

Fig. 3

LFVRPTW example

Note that in the LFVRPTW context, time windows are referred to as service-time-windows. Hence, if a transshipment at a customer of type-1 is necessary, the time window can be neglected but only for the transshipment task. In other words, if the type-1 customer (which is used as VD) is also served by the small or large vehicle, then the time window must be considered for the service task. The service task can be performed before or after the transshipment task.

In summary, the degree of freedom for the LFVRPTW is restricted if time windows are used. To be able to move a tour forwards or backwards in time to make a linkage possible, strongly depends (yet not solely) on the characteristic of the individual time windows. Hence, we can conclude that if certain characteristics like short travel distances, short service and transshipment times and wide time windows are met, the LFVRPTW algorithm may be able to find a solution with synchronised tours.

4 Heuristic approach

4.1 Formal definition of the LFVRPTW

The LFVRPTW is defined on a directed graph $G=(V,E)$ with a set of nodes (V) including the depot (0) and a set of customers (C) which is further divided into customers of type-1 (set A) and type-2 (set B). With each customer are associated a non-negative demand ($d_i$), non-negative service time ($t^S_i$) and service time window $[a_i,b_i]$ with earliest starting ($a_i$) and latest starting time ($b_i$). The set of edges ($e_{i,j}$) is represented by (E) and they correspond to the travel links between two customers (i) and (j). Each edge has the non-negative travel time ($t_{i,j}$) and non-negative travel cost ($c_{i,j}$). All customers are served by a heterogeneous fleet F of small ($F_{SV}$) and large ($F_{LV}$) vehicles (k) with a max. vehicle capacity ($Q^k$).

All vehicles are dispatched from one physical depot (PD) and the total tour duration must not exceed a given time limit. Customers of type-1 are assumed to have enough parking space and can therefore be visited by both vehicle classes whereas customers of type-2 can only be visited by the small vehicle class. Furthermore, the service for all customers must start within a certain time window. What sets the LVFRPTW apart from other VRP variants is the possibility for the small vehicle class to use the large vehicle class as virtual depot (VD). Instead of driving back to the depot if the capacity is depleted, the small vehicle can meet with a large vehicle at a customer of type-1 for a reloading operation. If goods are transferred from one vehicle to the other, a non-negative transshipment time of ($t^{TS}_{VD}$) for a transshipment load of ($q^{TS}_{VD}$) is required.

The detailed mathematical model formulation for the LFVRP(TW) together with some numerical results was already presented in Brandstätter and Reimann (2018b). As the LFVRP requires time related constraints to ensure synchronisation between vehicles, the mathematical model formulation of the LFVRP and LFVRPTW differ only in two constraints (see constraints 44 and 45 in Brandstätter and Reimann 2018b), which secure time window feasibility.

4.2 LFVRPTW algorithm for the linkage-approach

The basic concept of the LFVRPTW algorithm is very similar to the LFVRP algorithm we proposed in Brandstätter and Reimann (2018a). To be able to handle time windows (for customer service only), we have to adjust the four improvement strategies metaheuristic (ME), matheuristic (MA), generating multiple solutions (MS) and local search (LS) accordingly. Thus, we provide a general overview of the algorithm and describe the adjustments to the respective improvement strategies afterwards.

The overall concept of the algorithm can be described in four steps. In the first step, we solve the VRPTW for all type-2 customers with the metaheuristic Ant Colony Optimisation (ACO). For a general overview of ACO the interested reader is advised to see Dorigo and Blum (2005). The basic concept of ACO is to simulate the behaviour of real-world ants during their search for food. Real-world ants provide a pheromone trail when they search for food. The level of pheromone will increase if another ant uses the path and decrease otherwise. An ant is more likely to choose a path with a higher pheromone level as it was already used by fellow ants indicating a shorter path. Hence, the pheromone level evolves/changes over time and therefore ACO can be assigned to the learning mechanism category of metaheuristics. For our algorithm we use the ACO implementation for the VRPTW of Senarclens de Grancy (2015).

After solving the VRPTW for all type-2 customers, we optimise each small vehicle route individually by applying the principle of matheuristics in our second step. As the name indicates, matheuristics use the benefits of mathematical problem solving and heuristics - thus a hybrid algorithm. Specifically, we use the decomposition technique which extracts a smaller sub-problem from the main problem. In the next step we solve that sub-problem to optimality and reintegrate the solution of the sub-problem back to the main problem. In our case, the sub-problems are represented by the individual small vehicle tours. In other words, we have to solve the Travelling Salesman Problem with Time Windows (TSPTW) for each small vehicle tour. In our algorithm, we use the mathematical problem solver Gurobi Optimizer (see Gurobi Optimization 2016) for the matheuristic strategy.

In the third step, we generate multiple solutions with different characteristics and strategies. The idea of a multiple solution strategy originates from the fact that synchronised tours can hardly be optimised with the well-known VRP operators (e.g. exchange or relocate) often used by local search procedures. Hence, generating multiple solutions and choosing the best among them is a quite promising approach as we already showed in Brandstätter and Reimann (2018a). Therefore, we check the synchronisation against the first- and second-best VD and PD in terms of minimum distance. In addition, we apply the basic concepts of the most common bin packing strategies (e.g. Delorme et al. 2016) named First Best Fit (FBF), First Fit (FF), Best Fit (BF) and Worst Fit (WF) together with the originally proposed algorithm of the Linkage-Approach from our first paper (see Brandstätter and Reimann 2018b).

From the set of multiple solutions generated in the previous step, we select the best solution with minimum costs and apply a local search procedure in the fourth and final step. The LS procedure searches the solution space (neighbourhood) to find a superior solution. In our example, we use a destroy & repair mechanism for the LS procedure. Finally, the overall algorithm for the LFVRPTW algorithm is presented as pseudo-code in Algorithm  1.

4.3 Improvement strategy adjustments for time windows

4.3.1 Metaheuristic strategy (ME)

The metaheuristic strategy uses ACO to solve the VRPTW for all type-2 customers. The foundation of ACO is the well-known I1 heuristic proposed by Solomon (1987) which works as follows: In the first step, we select a seed customer and insert it between the start- and end-depot resulting in the first vehicle tour. Afterwards, we add the customers to that tour according to their insertion costs. That procedure continues as long as an insertion results in a feasible tour; feasibility in terms of capacity, time windows and tour duration. If no further customer can be inserted, the algorithm starts a new tour with another seed customer and proceeds with the remaining customers as mentioned before. These steps are repeated until all customers are served.

The ACO metaheuristic constructs a feasible solution for every artificial ant (m) multiple times until a certain stopping criterion (max. number of iterations or time limit) is met. However, contrary to Solomon’s I1 heuristic, ACO uses a probabilistic customer selection with the probability $P_{jkl} = \frac{\kappa _{jkl}}{\sum _{i \in I} \kappa _i}$ to insert a customer (k) with the attractiveness ($\kappa _{jkl}$) between nodes (j) and (l). Whereas the attractiveness for the seed customer is calculated as $\kappa _{jkl} = c_{jk}(\tau _{jk}+\tau _{kl})$ with ($c_{jk}$) as distance between depot (j) and customer (k) and $(\tau _{jk}+\tau _{kl})$ as the pheromone levels of the respective edges. The attractiveness to insert a customer (k) into an already existing tour is calculated as the inverse of the normalized costs $\overline{cost_{jkl}}$ (normalised to avoid a division by 0). The costs are calculated as $cost_{jkl} = \gamma _{jkl} T_{jkl}$ if $\gamma _{jkl} \le 0$ and $cost_{jkl} = \gamma _{jkl}/T_{jkl}$ otherwise. Here $\gamma _{jkl} = c_{jk}+c_{kl}-c_{jl}-2c_{0k}$ represents the additional distance costs and $T_{jkl}=\frac{\tau _{jk}+\tau _{kl}}{2\tau _{jl}}$ the pheromone trail value.

As mentioned before, the ants lay a pheromone trail on their used paths. That pheromone level decreases (evaporates) over time if the path is not used. On the other hand, if that path is used by another ant, the pheromone level increases. Therefore, before the first iteration starts, the pheromone level for all edges is set to 1 ($\tau _{ij} = 1$) and updated after each iteration by $\tau _{ij} = \tau _{ij} \rho + (1-\rho )x_{ij}$ with ($\rho$) as pheromone persistence factor and $x_{ij}$ as decision variable if the path is in the current solution. Finally, the ACO implementation is concluded by a LS procedure with three operators (shake-reduce, exchange and relocate). A detailed description of the ACO design can be found in Senarclens de Grancy (2015).

4.3.2 Matheuristic strategy (MA)

In Brandstätter and Reimann (2018a) we use the mathematical model formulation of Dantzig et al. (1954) to solve the Travelling Salesman Problem (TSP). Yet, this formulation does not include any time restrictions. Therefore, we use the TSPTW formulation of Dash et al. (2012) which was originally proposed as Big-M-Formulation by Ascheuer et al. (2001). However, this formulation does not fully cover our needs and some additional adjustments are necessary. The final TSPTW model formulation for our algorithm is as follows.

The set of nodes (V) is represented by the set of customers (C) and the starting (p) and end (q) depot (for simplification we split between start and end depot). All nodes have associated coordinates, service times ($t^{s}$) and a time window with the earliest starting time ($a_i$) and latest starting time ($b_i$). The driving distance ($c_{i,j}$) between respective nodes (i) and (j) is represented by the Euclidean distance. Finally, the objective is to minimise the total costs (z).

Parameters

z:

total costs

C:

set of customers

p:

start depot

q:

end depot

$V ={C \cup \{p,q\}}$:

set of nodes

$c_{i,j}$:

distance between node i and j

$c^{f}$:

fuel cost [currency/km]

$c^{w}$:

drivers wage [currency/hour]

$t^{a}_i$:

arrival time at node i

$t^{d}_{i,j}$:

driving time from node i to j

$t^{s}_{i}$:

service time of node i

$a_i$:

earliest starting time of node i

$b_i$:

latest starting time of node i

M:

sufficient large number

Decision variable

• $x_{i,j}={\left\{ \begin{array}{ll} 1, &{}\quad \text {if vehicle uses edge } i \text { to } j\\ 0, &{}\quad \text {else} \end{array}\right. }$

The objective function considers the total driven distance ($\sum \nolimits _{i \ne j,(i,j) \in V} c_{i,j}x_{i,j}$) and the total required time ($t^{a}_q-t^{a}_p$). The cost factors ($c^{f}$) represent the fuel consumption of the vehicle and ($c^{f}$) the drivers wage [currency/hour]. The objective function is presented in Eq. (4).

4.3.3 Objective function

$$\begin{aligned} \min z = c^{f} * \sum \limits _{i \ne j,(i,j) \in V} c_{i,j}x_{i,j} + c^{w} * (t^{a}_q-t^{a}_p) \end{aligned}$$

(4)

4.3.4 Constraints

$$\begin{aligned}&\sum \limits _{j \in \{C \cup \{q\}\}}x_{i,j} = 1&\quad i \ne j,\quad \forall i \in C \cup \{p\} \end{aligned}$$

(5)

$$\begin{aligned}&\sum \limits _{i \in \{C \cup \{p\}\}}x_{i,h} - \sum \limits _{j \in \{C \cup \{q\}\}}x_{h,j} = 0&\quad i \ne h,\quad h \ne j,\quad \forall h \in C \end{aligned}$$

(6)

$$\begin{aligned}&t_i + t^{d}_{i,j} + t^{s}_{i} - M * (1-x_{i,j}) \le t_j&\quad i \ne j,\quad \forall (i,j) \in V \end{aligned}$$

(7)

$$\begin{aligned}&t^{a}_{i} \ge a_i x_{i,j}&\quad i \ne j,\quad \forall (i,j) \in V \end{aligned}$$

(8)

$$\begin{aligned}&t^{a}_{i} \le b_i + M * (1-x_{i,j})&\quad i \ne j,\quad \forall (i,j) \in V \end{aligned}$$

(9)

$$\begin{aligned}&x_{i,j} \in \{0,1\}&\quad i \ne j,\quad \forall (i,j) \in V \end{aligned}$$

(10)

$$\begin{aligned}&M=max(b_{i})_{\forall i \in V}+\phi&\phi > 0 \end{aligned}$$

(11)

Constraints (5) ensure that all customers are visited, whereas the continuous routing flow is assured with (6). The time progress is assured with constraints (7). The compliance with time windows is secured with constraints (8)–(9). Finally, the last two constraints secure the definition of the decision variable (10) and that M is sufficiently large (11). The validity of the model has been tested against the formulation of Dash et al. (2012).

4.3.5 Multiple solutions strategy (MS)

The multiple solution strategy is the main part of our algorithm. For a better understanding, we describe the four previously mentioned bin packing algorithms briefly and also provide a small explanatory example in Fig. 4. Figure 4a shows the result after the MA strategy with six SV tours already positioned according to their time windows. What we can observe is that a linkage might only be possible between SV1 $\rightarrow$ {SV3, SV4, SV6}, SV2 $\rightarrow$ {SV3, SV4, SV6} and SV5 $\rightarrow$ {SV3, SV6}. To begin with, the FBF algorithm selects the first SV tour as starting tour and checks if a linkage is possible with the next tour. Thus, we replace the edge from the last customer of the first tour to the PD ($e_{i,PD}$) by the edge to the VD ($e_{i,VD}$) and the edge from the PD to the first customer of the next tour ($e_{PD,j}$) with the edge from the VD to the first customer ($e_{VD,j}$), respectively (see Fig. 4b: within the MS strategy, we check the best VD location for the first- and second-best customer as well as the PD. However, for simplification of this example, we consider only the best VD for now). If the linkage is feasible, it is stored temporarily and the next possible SV tour is checked. That procedure continues until all other possible SV tours are tested. After the linkage between the starting tour and all other tours is checked, the best possible linkage (if there is any) is selected - therefore First Best Fit.

The other algorithms are based on the same principle: selecting an SV tour as a starting tour and checking a possible linkage with the other possible SV tours. They only differ in the result selection when a linkage is accepted. For instance, the FF algorithm accepts a linkage as soon as a feasible linkage is found. Whereas the result selection in the BF/WF algorithm is not performed until every SV tour has been used as starting tour to select the best/worst result in terms of minimum resulting cost, the BF/WF algorithm is repeated until no further linkage is possible.

Fig. 4

Multiple solutions strategy

The multiple solution strategy developed for the LFVRP can almost be used for the LFVRPTW, with only two exceptions. First, if we do not use time windows, a small vehicle tour can be considered forwards (FW: e.g. $PD \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 4 \rightarrow PD$) and backwards (BW: e.g. $PD \rightarrow 4 \rightarrow 3 \rightarrow 2 \rightarrow 1 \rightarrow PD$). In other words, if we try to link two SV tours through a VD, we are able to create 4 possible combinations (FW-FW, FW-BW, BW-FW and BW-BW). As the VD will be inserted between the last customer of the first tour and the first customer of the second tour, it is possible that a different VD is used which may result in lesser costs. Yet, with time windows in place, the tour direction is predefined through the time windows and therefore we cannot consider the backwards version of the tour in the LFVRPTW.

The second change required for the LFVRPTW is the feasibility check. In the LFVRP algorithm we only had to assure that the constraints for capacity, transshipment (small and large vehicle have to be at the same place at the same time to perform a transshipment) and maximum allowed tour duration are met. Now we also have to ensure that all service starting times are aligned with their respective customer time windows. For a better understanding, we illustrate the feasibility check with two simplified equations [see Eqs. (12) and (13)].

$$\begin{aligned} q^{a}_{j}&={\left\{ \begin{array}{ll} q^{a}_{i} - d_{i}\alpha + q^{TS}_{SV}\beta , &{}\quad \text {if}\quad q^{a}_j \ge d_{j}\\ \text {not feasible}, &{}\quad q^{a}_j < d_{j} \end{array}\right. }\nonumber \\&\quad i \ne j,\quad \forall (i,j) \in V,\quad \alpha \in \{0,1\},\quad \beta \in \{0,1\} \end{aligned}$$

(12)

$$\begin{aligned} t^{a}_{j}&={\left\{ \begin{array}{ll} t^{a}_{i} + t^{s}_{i}\alpha + t^{TS}\beta + t^{d}_{i,j}, &{}\quad \text {if}\quad a_j \le t^{a}_{j} \le b_j \\ a_j , &{}\quad t^{a}_{j} < a_j \\ \text {not feasible}, &{}\quad t^{a}_{j} > b_j \end{array}\right. }\nonumber \\&\quad i \ne j,\quad \forall (i,j) \in V,\quad \alpha \in \{0,1\},\quad \beta \in \{0,1\} \end{aligned}$$

(13)

The feasibility check for the capacity is presented in Eq. (12). Here ($q^{a}_{j}$) represents the load of the vehicle upon arrival and is calculated as the vehicle load upon arrival at the previous customer ($q^{a}_{i}$) minus the customer demand ($d_{i}\alpha$: if a service is performed ($\alpha =1$)) plus the transshipment load ($q^{TS}_{SV}\beta$: if a transshipment is performed ($\beta =1$)). If it ever occurs that ($q^{a}_j < d_{j}$), then the SV tour is infeasible. The feasibility check for the time is presented in Eq. (13). The arrival time at customer (j) is represented by ($t^{a}_{j}$) and is determined as the arrival time ($t^{a}_{i}$) at the previous customer (i) plus the customer service time ($t^{s}_{i}\alpha$: if a service is performed ($\alpha =1$)) plus the transshipment time ($t^{TS}\beta$: if a transshipment is performed ($\beta =1$)). However, if the arrival time is less than the earliest starting time ($t^{a}_{j} < a_j$), then the vehicle must wait until the time window opens. Therefore, the arrival time will be set to the value of the earliest starting time. If the arrival time is larger than the latest starting time ($t^{a}_{j} > b_j$), then the SV tour is infeasible and the feasibility check failed.

4.3.6 Local search strategy (LS)

For the last improvement step we use a large neighbourhood search (LNS) to further improve our solution. The basic principle is to search for a superior solution in the neighbourhood of a given solution. There are multiple LNS heuristics but we decided to use a destroy-and-repair procedure. That procedure destroys the initial solution and tries to repair it afterwards by using other characteristics than before. Our destroy-and-repair procedure requires five steps and works as follows.

We start by checking all SV tours for synchronisation as the LS procedure will only be applied to synchronised tours. Thus, the first SV tour with synchronisation is selected. In the next step, all reload positions (VDs and PD returns) from the SV tour and all reload positions and customers from the associated LV tour(s) are freed. Once the initial solution is destroyed, we optimise the SV tour with the MA strategy. Afterwards we insert all required VDs or PD visits back into the SV tour. But now we check all possible insertions that lead to a feasible solution. Thus, if we find a feasible solution, the associated LV tour(s) is (are) constructed (see Algorithm 1 lines 12–17) and stored temporarily. In the fifth and final step, we compare the initial solution with all temporarily stored solutions and select the superior one. Afterwards we apply the LS procedure to all other synchronised SV tours.

Fig. 5

Local search procedure

For a better understanding, we provide a small illustrative example in Fig. 5. The initial solution for the LS procedure consists of 1 SV tour ($PD \rightarrow 2 \rightarrow VD \rightarrow 1 \rightarrow 4 \rightarrow 3 \rightarrow PD$) with 4 customers and one VD and one LV ($PD \rightarrow 5 \rightarrow VD \rightarrow 6 \rightarrow PD$) tour with two customers. In the second step the VD is freed from the SV tour and the LV tour is destroyed completely. Afterwards the SV tour is optimized which results in a new SV tour $PD \rightarrow 1 \rightarrow 2 \rightarrow 3 \rightarrow 4 \rightarrow PD$. In the fourth step all possible insertions are checked and stored temporarily. In our example the first solution will be accepted as the new solution and the LS procedure continues.

5 Computational results

For our computational results we used the following hard- and software configuration. The coding was done in programming language C and compiled with GNU GCC Compiler on a 4 * $\hbox {Intel}^{\textregistered }$ $\hbox {Core}^{\mathrm{TM}}$ i7-5557U CPU @ 3.1 GHz processor and 16 GB DDR3 RAM (1.6 MHz) under a 64-Bit Operating System (Kubuntu 14.04). For the mathematical problem solver, we used the optimization software Gurobi Optimizer (Version 6.5.1) and coded the mathematical formulation of the TSPTW with the programming language Python (Version 2.7.6).

Furthermore, our analysis is divided into two parts. In the first part we want to understand the impact of different time window characteristics. To do so, we decided to generate multiple instances with large, medium and tight time windows and compare our results to the classical VRPTW and HFVRPTW. For the second part we will compare our results to the best-known results (BKS) of the LFVRPTW. However, a thorough comparison is not possible because some vital information is missing on how the BKS were obtained. Yet, for the sake of completeness, we decided to make logical assumptions to be able to compare our results to the BKS.

5.1 Setup for the LFVRPTW algorithm

The algorithm for the LFVRPTW was programmed to be as flexible as possible. If not indicated otherwise, the algorithmic set-up is as follows. The input files of the test instances consist of a single depot (PD) and multiple customers with associated characteristics (x-coordinate, y-coordinate, demand, time window: earliest starting time and latest starting time, service time and customer type). The driving distance between two nodes is the Euclidean distance and driving time the Euclidean distance divided by the average speed of the vehicle class. Although the service time is given by the test instance, we designed the algorithm to use unit-dependent service and transshipment times. To achieve that, we defined the required time for a complete transshipment of the small vehicle’s capacity and calculated the transshipment and service time according to transshipment load and demand. As shown in our second paper we remained with 10 repetitions per instance as default. If not explicitly indicated, the results are the best found results out of these 10 repetitions.

Furthermore, all four improvement strategies (ME, MA, MS and LS) are enabled by default. Although we were able to solve all sub-problems of the matheuristic strategy in Brandstätter and Reimann (2018a) in a reasonable amount of time (less than 3 s), we realized some difficulties when we applied that principle to the LFVRPTW. The reasons for that are the additional time constraints used in the TSPTW model formulation. We figured out that larger sub-problems required more than 60 s to find a feasible/optimal solution. As a result, we decided to set the time limit for the calculation time of the mathematical problem solver to 10 s. The solver will only return a solution to the algorithm if a superior solution is found or otherwise the algorithm will proceed with the starting solution.

Finally, the main objective of our comparison are the total required costs which are calculated as the sum of (i) fixed costs (number of used vehicles $no.^{k}$ multiplied by the associated fixed costs $f^{k}_{fix}$), (ii) fuel consumption costs (total distance $dist.^{k}$ per vehicle class k multiplied by the variable costs per length unit $f^{k}_{fuel}$) and (iii) costs for the drivers wage (total required time $time^{k}$ of the vehicle class k multiplied by the variable costs per time unit $f^{k}_{wage}$).

$$\begin{aligned} costs&= no.^{SV}*f^{SV}_{fix} + dist.^{SV}*f^{SV}_{fuel} + time^{SV}*f^{SV}_{wage} \nonumber \\&\quad + no.^{LV}*f^{LV}_{fix} + dist.^{LV}*f^{LV}_{fuel} + time^{LV}*f^{LV}_{wage} \end{aligned}$$

(14)

5.2 Impact of different time window characteristics

Since time windows have a huge impact on the effectiveness of the routing (see Russo and Comi 2010), a thorough analysis is essential. Therefore, we decided to analyse three time window categories: 2 h ([0–2],[2–4],[4–6],[6–8],[8–10] and [10–12]), 4 h ([0–4],[4–8] and [8–12]) and 6 h ([0–6] and [6–12]) with a tour duration limit (and maximum time window of the depot) of 12 h. As for the customer location and demand values, we chose the C, R and RC sets of the well-known Solomon problem instances (see Solomon 1987). However, as the customer location will only differ between the C, R and RC instance sets, the customer distribution of type-1 and type-2 customers was initially set and not changed afterwards. We assumed that the majority of the customers are hardly accessible and therefore decided to set the customer distribution to 1:3. Thus, 25% of the customers are of type-1 and can be chosen as a VD, whereas the majority of the customers (75%) are of type-2. To gain a large set of different test instances, we created 10 test instances with randomly assigned time windows for each test instance set and time window category. Consequently, we generated 90 ($3[\hbox {C,R,RC}]^{*}3[2,4,6]^{*}10=90$) test instances for our analysis.

Moreover, we used the same costs and service/transshipment setup as in Brandstätter and Reimann (2018a). We assumed a reload time of 15 min for the full capacity of the small vehicle and the service times in relation to the demand of each customer. For the large vehicle we consider a truck with a trailer (40t payload—capacity for the test instances is the sum of the total customer demand) with daily costs of €200 per vehicle ($f^{LV}_{fix}$) , fuel consumption of €0.35/km ($f^{LV}_{fuel}$—35l per 100 km) and a drivers salary of €30 per hour ($f^{LV}_{wage}$) and for the small vehicle we use a cargo-bike (150 kg payload—capacity for the test instance set is 50 units) with costs of €2 per day and vehicle ($f^{SV}_{fix}$), €0.00/km ($f^{SV}_{fuel}$: no fuel consumption) and the drivers salary of €20 per hour ($f^{SV}_{wage}$). The average speed of the small vehicle is assumed with 15 km/h and 40 km/h for the large vehicle.

For a better comparison we present the results for the LFVPRTW together with the VRPTW and HFVRPTW. The VRPTW results were obtained by changing the customer type for all customers to type-2 and the HFVRPTW results by disabling the reload option at a VD. To get a deeper insight into the analysis with time windows we decided to present three aggregated tables. Table 1 shows the aggregated results of the different problems together with the time window category and instance set classification. The sole time window comparison regardless of the instance set is presented in Table 2. Besides the total costs, we also present the number of vehicles, driven distance, used time, number of reloads and required CPU time. Our analysis will be concluded by a deviation analysis and statistical comparison in Table 3. In all three tables the best results are indicated by bold values and the minimum results for all three problems and for all generated instances can be found in the appendix.

Table 1 Instance set analysis

Table 2 Time window analysis

We observe that the LFVRPTW is the superior approach for all time window categories and almost all instance sets. Only for the mixed customer distribution with the 4 h time window category the HFVRPTW was able to provide a superior result. For the randomly generated customer distribution within the same time window category, the HF- and LFVRPTW provide almost the same results. As expected, the VRPTW is the least effective approach. That is due to the fact that the other two approaches allow the use of large vehicles. If large vehicles are allowed, the HF- and LFVRPTW are able to reduce the number of required small vehicles significantly (between 10 and 15 vehicles).

Another interesting observation is that, on average, the required CPU time for the LFVRPTW is higher than for the other two approaches. Yet, the difference between the results of the HFVRPTW and the LFVRPTW is rather small compared to the VRPTW. The reasons for that can be found within the two improvement strategies MS and LS. As the usage of a VD is prohibited within the VRPTW and HFVRPTW, the MS and LS strategy will not be used. Furthermore, the LFVRPTW requires significantly more CPU time for the 6 h time window category (compare CPU times in Table 2), whereas the CPU time for the VRPTW and HFVRPTW show hardly any deviation regardless of the time window category or instance set. If time windows are tight, the possibilities for suitable VD locations or potential linkage of tours are limited. However, these possibilities increase if time windows become larger. Consequently, more possibilities within the MS and LS strategies need to be considered. As a result, additional computation time is required and superior final results are found.

Finally, we present the average costs per time window category together with the relative percentage deviation (RPD) and the p-values of the statistical comparison in Table 3. The RPD is calculated as $RPD=100*\frac{Cost_{x}-Cost_{LFVRPTW}}{Cost_{x}}$, where $x \in \{VRPTW, HFVRPTW\}$. As for the statistical comparison, we assume an equal solution quality with the null-hypothesis $H_0$ and the alternative-hypothesis $H_1$ if the difference in solution quality is significant. If the p-value is less than 0.05, the null-hypothesis can be rejected. For our statistical analysis we used the Wilcoxon-Signed-Rank-Test (WSRT see Wilcoxon 1945) which we performed with R.

Overall, the results of the LFVRPTW are superior compared to those of the VRPTW and HFVRPTW. However, when we have a closer look at the different time window categories, the HFVRPTW can compete with the LFVRPTW if the time windows are of medium size (4 h). The reason for that are the required number of vehicles. While the HFVRPTW requires the same number of large vehicles if the time windows are medium or large, more large vehicles are needed if the time windows are tight. Although this may be true for the HFVRPTW, it is not the case for the LFVRPTW. If time windows are medium or tight, the LFVRPTW requires almost the same number of small and large vehicles. Only if the time windows are large, the LFVRPTW is also able to reduce the number of large vehicles. Having that in mind and that the costs for the large vehicle class are a lot higher than the costs for the small vehicle class, the difference in the number of large vehicles has a substantial effect on the total costs. This can be seen in Table 3 with the RPD analysis. With tight and large time windows the LFVRPTW provides superior results. Only if the time windows are of medium size, the HFVRPTW provides better results. From a statistical point of view, the above observation can be confirmed for tight (instance set c) and large sized time windows with a significant advantage of the LFVRPTW. However, for medium sized time windows, the LFVRPTW and HFVRPTW provide equal results in terms of solution quality.

5.3 Comparison to best-known LFVRPTW results

To the best of our knowledge, the current BKS for the LFVRPTW have been provided by Chen and Wang (2012). To be able to compare our results we had to change the set-up of our algorithm slightly to the information provided. Nevertheless, not all required parameter information was provided for a proper comparison. Yet, we were able to find some missing parameters in Chen et al. (2011a) and concerning the rest we made logical assumptions. However, we were still not able to solve all test instances as some customers could not be served within their respective time windows. Thus, we had to adjust some of the given customer time windows. In summary, we collected the parameters from multiple papers, made logical assumptions and adjusted some customer time windows to be able to find feasible solutions. But we were not able to make a solid comparison to the BKS for the LFVRPTW due to the prior mentioned problems. Therefore, we decided to skip the BKS comparison from the main part of this paper. Yet, for the sake of completeness, we presented our comparison approach in the appendix.

Table 3 Relative percentage deviation and statistical comparison

6 Conclusion

Time windows play an important role for city logistics because the delivery of goods is very often time dependent (e.g. opening hours or delivery only in the morning hours). Therefore, time windows need to be addressed accordingly in vehicle routing research. In our previous papers we introduced a new problem which is called the LFVRP; where small and large vehicles are used for delivery and synchronisation between vehicles is possible. Yet, time windows have not been considered so far. With this paper we close this gap by providing a thorough analysis on the impact of time windows on the LFVRPTW.

We started with an overview of relevant literature followed by a structural analysis to better understand the problem with time windows. Due to earlier findings, we further developed/extended the Linkage-Approach by means of the four improvement strategies metaheuristic, matheuristic, generating multiple solutions and local search from our previous paper. The metaheuristic strategy (ME) creates small vehicle tours for all type-2 customers while the matheuristic strategy (MA) tries to find the optimal solution for each tour. As the name already indicates, the multiple solution strategy (MS) generates multiple solutions by using different construction techniques and reload positions. Finally, the local search strategy (LS) uses a destroy-and-repair mechanism to further improve the solution. In our computational analysis we developed 90 test instances with different time windows using three different time window categories: tight (2 h), medium (4 h) and large (6 h). For a better comparison, we provided results for the VRPTW and HFVRPTW. In conclusion, the LFVRPTW provides significantly superior results for tight and large time windows. For medium sized time windows, the LFVRPTW requires more large vehicles and therefore the HFVRPTW is slightly (yet not significantly) superior.

The insights of this paper serve as a solid foundation for future research on the LFVRPTW. Although the width of the time windows is crucial for the advantage of the LFVRPTW, alternative algorithmic approaches could provide superior results. For example, it would be interesting to merge the MS with the ME strategy and create multiple starting solutions. In this case, the algorithm would have more possibilities for potential reload positions. Another approach would be to use an alternative construction approach like parallel route construction heuristics. Clearly the LFVRPTW shows great potential—especially for city logistics—but still needs to be investigated in more detail.

Appendix

According to Chen and Wang (2012) the required parameters are as follows. For the small vehicle class the costs (in New Taiwan Dollar NTD) are 600 NTD/day for rent and insurance ($f^{SV}_{fix}$), 0,77 NTD/km fuel cost ($f^{SV}_{fuel}$) and 120 NTD/h the drivers wage ($f^{SV}_{wage}$), whereas the costs for the large vehicle are 1450 NTD/day for rent and insurance ($f^{LV}_{fix}$), 3.3 NTD/km fuel cost ($f^{LV}_{fuel}$) and 270 NTD/h the drivers wage ($f^{LV}_{wage}$). Furthermore, the small vehicle capacity is associated with each test instance and the large vehicle capacity is ten times the small vehicle capacity.

However, not all required information (e.g. average speed and transshipment/reload time) has been provided by Chen and Wang (2012). Therefore, we assumed the average speed of 40 km/h (as presented for the small vehicle class in Chen et al. 2011a) for both vehicle classes and the transshipment/reload time of 10 units. Yet, with the provided information at hand, it was still impossible to provide a feasible solution for some instances as some customers could not be served within their provided time windows. In these cases the earliest starting time ($a_i$) plus service time ($t_i^{s}$) plus travel time back to the depot ($t_{ij}$) is greater than the latest arrival time at the depot ($b_0$): $a_i + t_i^{s} + t_{ij} > b_0$ or the travel time to the customer ($t_{0i}$) is greater than the latest starting time of the respective customer ($b_i$): $t_{0i} > b_i$. As the customer time windows were provided in four categories [08:00–20:00], [08:00–12:00], [12:00–17:00] and [17:00–20:00], we had to change the respective customer time windows to the next possible category to be able to create feasible solutions.

Table 4 Chen: LFVRPTW result comparison

The results of our algorithm are summarized in Table 4 together with the results of the ELFVRPTW provided by Chen and Wang (2012). For 10 out of 17 test instances we were able to provide superior results compared to the ELFVRPTW. Furthermore, in terms of average total costs, our algorithm totally outperformed the ELFVRPTW (13944 compared to 18719). Unfortunately, Chen and Wang (2012) did not provide the number of vehicles nor required distances and time which made it difficult to provide a more detailed analysis. Yet, if we have a closer look at the reload column, we can see that the algorithm was not able to link some small vehicle tours through a VD or the PD. In other words, as no reload or transshipment takes place and no large vehicle is used, the result of our algorithm can be seen as a VRPTW result. Although the computation time is hardly comparable due to different hardware configuration, it is worth mentioning that our algorithm needs on average approx. 4 times longer than the ELFVRPTW. The reason for that is the usage of our four improvement strategies ME, MA, MS and LS.

In summary, our algorithm clearly outperforms the algorithm provided by Chen and Wang (2012), but we require more computation time and do not use a VD or PD for reloading. However, it is difficult to perform a thorough comparison because Chen and Wang (2012) did not provide the necessary information to comprehend the reported results. In addition, we also had to make some assumptions and some instances needed a time window adjustment to be able to create a feasible solution. Hence, for future research on the LFVRPTW, we recommend to use our results of Table 4 which provide all necessary information for a solid comparison.

1.1 Data tables

In the following three tables we present the results for the LFVRPTW in Table 5, VRPTW in Table 6 and HFVRPTW in Table 7.

Table 5 Results LFVRPTW

Table 6 Results VRPTW

Table 7 Results HFVRPTW