A Heuristic Approach for Last-Mile Delivery with Consistent Considerations and Minimum Service for a Supply Chain

Abstract

This paper considers the problem of consistent routing with minimum service (ConVRPms). ConVRPms aims to determine the minimum cost routes for each day of a planning horizon. In particular, the goal is to satisfy all individual demands and serve every customer via a single driver, with times that do not differ by more than $L$ time units. There is a fleet of homogeneous vehicles that start from a single depot. In this paper, a heuristic algorithm for ConVRPms is proposed. The algorithm is based on classical constructive heuristics and the tabu search metaheuristic. The proposed algorithm has been tested on benchmark instances from the literature. The experimental results show that the proposed approach produces high-quality solutions within computing times considerably less than those observed with CPLEX. The proposed algorithm can optimally solve instances with 20 customers and a planning horizon of three days, producing more economical solutions in some of the larger instances and those requiring hourly consistency ($L=1 \mathrm{h}$).

1. Introduction

In modern industries, companies seek to highlight their efficiency by implementing differentiation strategies. Some companies seek to develop a competitive advantage by delivering higher-quality service and developing loyalty ties with their customers. The consistency of delivery is a fundamental factor to consider in increasing the quality of service, especially for courier service companies, package distribution, health and home care, and cleaning services. Ref. [1] argued that ensuring consistent schedules and limiting the number of drivers with which a customer must interact can significantly improve customer satisfaction, facilitate reception operations, and improve trust between the company and the customer.

Researchers have proposed solution strategies to increase the quality of periodic service and minimize the impact of operational costs. Ref. [2] introduced the Consistent Vehicle Routing Problem (ConVRP), inspired by the courier and parcel delivery industry. The ConVRP is a variant of the well-known vehicle routing problem (VRP), which is focused primarily on customer satisfaction through consistent periodic service. In the ConVRP, the objective is to determine the routes to be performed with the minimum cost for a fleet of homogeneous vehicles operating daily within a planning horizon. The ConVRP seeks to satisfy all the demands, and a single driver/supplier must regularly serve each customer for multiple periodic visits.

Given its economic relevance, applicability, and complexity, the ConVRP has been studied by multiple researchers, who have proposed various variants and applications of the problem, and heuristic or exact algorithms for its solution. The ConVRP has been classified as NP-hard [2]. Ref. [2] indicates that the constraints associated with temporal consistency significantly complicate the problem’s solution since they introduce interdependencies between the routes for multiple days.

Ref. [3] introduced the Consistent Vehicle Routing Problem with Minimum Service (ConVRPms). Unlike the traditional ConVRP, the ConVRP considers that the number of vehicles is defined a priori, and that each driver/supplier must serve at least one customer on each day of the planning horizon. The ConVRPms is a combinatorial optimization problem aimed at increasing consumer satisfaction through the delivery of a periodic service through the same driver/supplier and at regular times. Ref. [3] designed a set of small, structured instances for ConVRPms, in which the efficiency of an exact branch-and-cut method was tested. ConVRPms is a problem whose application is helpful for the operational planning of the courier service and package distribution industries, determining high-quality routes and meeting the essential criteria of the ConVRP.

The main contribution of this paper is the proposal of a heuristic solution method for ConVRPms that produces high-quality solutions within short computing times for large instances. The general motivation of the paper is to introduce an efficient approach to solving several variants of the vehicle routing problem, considering the consistency of the driver and the time to be visited. This approach could be applied to several industries related to health delivery problems for medication and patient visits. In the literature review, there are no published efficient algorithms that are based on heuristic approaches for solving the ConVRPms. The former algorithm is deterministic and considers a sequential structure. The proposed approach involves constructive heuristics and local search procedures based on a tabu search (TS) metaheuristic. TS has been selected because of its excellent performance in solving several complex variants of the well-known VRP [4,5]. Indeed, the TS approach is easy to implement, and the short-term memory generates an extraordinary exploration of the search space, avoiding local optima. In addition, its intensification strategy allows the proposed approach to obtain high-quality solutions within short computing times. The proposed strategy could be extended to the solution of current and future variants of the ConVRP, contributing to a reference framework for future research.

2. Literature Review

Vehicle routing problems are a family of combinatorial optimization problems that seek to determine the routes of a set of vehicles to serve a set of customers. Generally, the objective of such problems is to minimize the total operation cost or transit time. However, the objective and its constraints depend on the specific characteristics of the problem. The ConVRP is a variant of the traditional VRP that seeks consistency in visits to customers because visits on routes must be performed by the same driver and at the same hour.

Ref. [2] introduced the Consistent Vehicle Routing Problem (ConVRP) inspired by the courier and parcel delivery industry. In this work, an arc-based mixed-integer programming model is formulated, and a two-stage heuristic method (ConRTR) is introduced. A set of routes is generated in the first instance, including all recurring customers. Then, the routes are scheduled each day from the initial routes, scheduling the daily demands of nonrecurring customers. The routes are improved via local search. A tabu search approach based on the concept of template routes ([2]) for the solution of the ConVRP was proposed by [6]. The proposed method adopts a two-level master–slave decomposition scheme. Initially, a master template is built to determine the sequence of delivered services to frequent customers for the planning horizon. An enhancement method based on tabu search modifies template routes and daily service schedules sequentially. The algorithm’s performance was compared on a set of instances introduced by [2].

Ref. [1] introduced the time-consistent vehicle routing problem (TCVRP), which focuses on transportation services for people with disabilities. This paper proposes a heuristic algorithm based on large neighborhood search (LNS), in which a VRP with time windows (VRPTW) without waiting times is solved. The performance of the LNS is compared with that of CPLEX for the set of instances designed by [2] and modified for the TCVRP.

Ref. [7] propose the generalized and multiobjective version of the ConVRP, in which the consistency constraints are relaxed, allowing a limited number of drivers per customer and the service schedule within any time window. In this work, an algorithm based on LNS is proposed for solving the problem, and 2-opt operators are applied to improve the consistency of the arrival times. On the other hand, a variable neighborhood search (VNS) for the approximate solution of the ConVRP was developed by [8]. The proposed algorithm considers two sequential phases. In the first phase, an initial solution is obtained that may be infeasible. In the second phase, the solution is repaired and improved in terms of quality. In addition, a special perturbation method has been proposed to diversify the search space. The performance of the VNS is compared with that of other previously published algorithms. The results show that the VNS performs better than the methods proposed by [2,6,7].

Ref. [9] proposes an alternative mathematical formulation for the ConVRP on the basis of sets of customers. For the solution of the model, a method based on column generation (CCG) is proposed. The CCG solves optimality instances with up to 30 customers within less than an hour, outperforming the efficiency of the arc-based model formulated by [2]. An LNS-based approach is proposed that is capable of generating higher-quality solutions within short computing times. Ref. [10] proposed the periodic vehicle routing problem with driver consistency (PVRP-DC). The problem is a variant of the PVRP, in which the same driver must serve every customer in the planning horizon. An algorithm based on branch-and-cut and a family of valid inequalities has been proposed to strengthen the linear relaxation of the problem. A set of 240 instances ranging from 10 to 70 customers is proposed, and the planning horizon varies between two and five days.

Ref. [11] introduces the ConVRP considering profits (ConVRP-Profit), whose objective is to determine the routes that maximize net profit while satisfying capacity, duration (DC), and consistency (ATC) constraints. An adaptive tabu search, which uses short- and long-term memory structures to guide the search process to solve the problem, has been proposed. The algorithm’s efficiency is tested on a set of instances taken from the literature and a new set of instances. The experimental results demonstrated the algorithm’s effectiveness, generating optimal solutions for small-size instances and achieving good performance for large-size instances.

Ref. [3] proposed a variant of the ConVRP, including minimum service constraints (ConVRPms). In this work, a mathematical model for the ConVRPms is formulated. A set of structured instances has been designed to analyze the model’s behavior concerning the number or geographic distribution of customers, the location of the depot, or the required level of consistency for arrival times. The performance of the commercial CPLEX and Gurobi solvers was compared with that of fully relaxed ATC constraints, generating solutions of equal quality and negligible differences within similar computing times.

Ref. [12] considers the consistent vehicle routing problem with time windows (ConVRPTW) motivated by the real application of a food distribution company. Unlike the original ConVRP, this variant relaxes the constraint that every customer is served regularly for the planning horizon. In particular, all the daily demands must be satisfied within the time intervals defined a priori. The objective of the problem is to reduce the total number of vehicles to be used to satisfy the demands for the planning horizon. This paper proposes a heuristic algorithm for the ConVRPTW based on an insertion heuristic to generate an initial solution and a set of heuristics for route elimination. Ref. [13] proposes a mathematical model for the ConVRP considering customers with multiple daily deliveries and other service level agreements, such as time windows and release dates. A decomposition approach is used to solve the considered problem. The proposed approach can solve large-size instances for real-life scenarios. Significant improvements in the total distance traveled and travel times are achieved.

Recently, published works addressing variants of the ConVRP have been proposed by [14,15,16,17,18,19]. A mixed-integer linear programming model and variable neighborhood search metaheuristic with several neighborhood structures for the ConVRP were proposed by [14].

A centrally organized multiperiod collaborative vehicle routing problem, where carriers can exchange customers who have to be served regularly, has been considered by [15]. This problem considers the basic aspects of the ConVRP, adding collaboration work to maintain the workload balance on routes (collaborative-consistent vehicle routing problem with workload balance—CWBConVRP). The authors propose a mathematical model including several valid inequalities for small-size instances. For large instances, an efficient iterated local search algorithm is developed. A variant of the ConVRP considering path consistency based on the underlying road network (ConVRPRN) was studied by [16]. The ConVRPRN considers a set of consistent vehicle routes within a certain period. The objective is to minimize the total travel costs while considering the discount for the paths’ consistent parts. A set-partitioning and a general-arc-flow model are proposed, which are solved by a branch-price-and-cut algorithm.

The ConVRP, with stochastic considerations of the demands, travel times, and service times, was studied by [17]. A hybrid algorithm with a large neighborhood search and simulated annealing is designed to address the proposed NP-hard problem. The Consistent Electric-Vehicle Routing problem with Backhauls and Charging Management was studied by [18]. Finally, the ConVRP considering heterogeneous fleets was introduced by [19].

The latest works considering variants of the ConVRP have been applied by [20,21,22]. Ref. [20] proposes an approach based on a real case for a company in the cleaning sector. The authors decompose the problem into two subproblems, namely, the planning and routing optimization subproblems. A large neighborhood search is applied for the considered problem. Ref. [21] proposed a POPMUSIC-based decomposition of a variable neighborhood search (VNS) scheme for a large-scale consistent vehicle routing problem. The former algorithm is constructive and consequently solves several subproblems to improve the current solution. Ref. [22] consider the problem of shops starting collaboration on urban same-day delivery by using shared vehicles and microdepots for the consolidated transportation of parcels. Consistent routes are designed to simplify the distribution process. The authors propose a two-stage stochastic model for the considered problem. The first stage determines the type of vehicle assigned, and the second optimizes the distribution of the orders.

Ref. [23] addresses a new consistent vehicle routing problem (ConVRP) by considering driver equity and flexible route consistency. For this variant, a flexible strategy to attain route consistency is introduced to traverse as many familiar routes as possible during the planning period by offering time discounts for routes crossed more than twice. A tailored adaptive large neighborhood search algorithm (ALNS) is developed to solve practical-sized problems. Ref. [24] considers stochastic aspects for customers within the ConVRP; a two-stage model, where the first stage assigns customers to drivers and in the second-stage customers are selected for each scenario. Ref. [25] proposes an exact algorithm based on a set-partitioning formulation and robust column and-cut generation for a workload-consistent vehicle routing problem with priority distribution and demand uncertainty.

The literature review revealed that no similar works have been introduced; however, efficient attempts based on heuristic algorithms for solving large-size instances of ConVRPms have been reported. The latest approaches have considered real applications for variants of the ConVRP, algorithms for large-size problems, and some exact approaches. However, exact approaches can solve small- to medium-sized problems within reasonable computing times. On the other hand, real applications are considered only to solve a specific problem, which could be difficult to extend to other variants. Finally, the approaches for solving large instances are close to being implemented for rich vehicle routing problems. We have developed an efficient approach for solving ConVRPms by combining local search procedures within a tabu search scheme.

3. Proposed Approach

3.1. Description of the ConVRPms

The ConVRP variant proposed by [3] aims to determine the minimum cost routes for each day of a planning horizon. In particular, the goal is to satisfy all individual demands and serve every customer via a single driver (DC constraint), with times that do not differ by more than $L$ time units (ATC constraint).

There is a fleet of homogeneous vehicles. The total number of customer products requested for a day by the customers assigned to a vehicle on a given day must be at most its load capacity $Q$. The number of products demanded by each customer can vary on different days. Each driver must serve at least one customer on each day of the planning horizon, and each route must begin and end at a single depot. The duration of any route must be, at most, the time limit of operation of $T$ time units. The time to deliver the service to a customer can vary within the planning horizon. Upon concluding the service delivery to the customer, the driver must move immediately to the next customer or the depot. Vehicle drivers must not continue in the middle of the route to wait.

The model for ConVRPms proposed by [3] is summarized as follows:

Sets:

• D: Planning horizon.
• K: Available vehicles.
• N: Customers.
• V: Nodes (the set N of customers plus the depot OR N₀).
• A: Arc connecting nodes.

Parameters:

• T: Maximum operating time.
• L: Maximum difference for the accepted arrival times.
• Q: Load capacity of the vehicle.
• q_id: Demand of customer i for day d.
• w_id: Requested service by customer i for day d. This parameter takes a value of 1, indicating that customer i has a demand on day d.
• t_ij: Travel time from node to node j.
• s_id: Service time of customer i for day d.

Decision variables:

• $x_{ijkd}=\left\{\begin{array}{c}1 \text{if the vehicle} k \text{visits the customer} j \text{after visiting customer} i \text{for the day} d\\ 0 \text{Otherwise}\end{array}\right.$.
• $y_{ikd}=\left\{\begin{array}{c}1 \text{if the customer} i \text{is served by the vehicle} k \text{for the day} d\\ 0 \text{Otherwise}\end{array}\right.$.
• $a_{id}=\mathrm{A}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{v}\mathrm{a}\mathrm{l} \mathrm{t}\mathrm{i}\mathrm{m}\mathrm{e} \mathrm{o}\mathrm{f} \mathrm{c}\mathrm{u}\mathrm{s}\mathrm{t}\mathrm{o}\mathrm{m}\mathrm{e}\mathrm{r}\mathrm{s}$ i on the day d.

Objective function and constraints

$$\min \sum _{d\in D}\sum _{k\in K}\sum _{\left(i,j\right)\in A}{t}_{ij}\ast x_{ijkd}$$

(1)

$$y_{0kd}=1 \forall k\in K, d\in D$$

(2)

$$a_{0d}=1 \forall d\in D$$

(3)

$$\sum _{k\in K}{y}_{ikd}=w_{id} \forall i\in N, d\in D$$

(4)

$$\sum _{i\in N}{q}_{id}\ast y_{ikd}\le Q \forall i\in N,d\in D,k\in K$$

(5)

$$\sum _{i\in V}{x}_{ijkd}=y_{jkd} \forall j\in N,k\in K,d\in D$$

(6)

$$\sum _{i\in V}{x}_{jikd}=y_{jkd} \forall j\in N,k\in K,d\in D$$

(7)

$$w_{i{d}_{\alpha }}+w_{i{d}_{\beta }}-2=y_{ik{d}_{\alpha }}-y_{ik{d}_{\beta }} \forall d_{\alpha },d_{\beta }\in D, i\in N,k\in K,d_{\alpha }\ne d_{\beta }$$

(8)

$$w_{i{d}_{\alpha }}+w_{i{d}_{\beta }}-2=y_{ik{d}_{\beta }}-y_{ik{d}_{\alpha }} \forall d_{\alpha },d_{\beta }\in D, i\in N,k\in K,d_{\alpha }\ne d_{\beta }$$

(9)

$$a_{id}+x_{ijkd}\left(s_{id}+t_{ij}\right)-\left(1-x_{ijkd}\right)\ast T\le a_{jd} \forall \left(i,j\right)\in A:j\ge 1,k\in K,d\in D$$

(10)

$$a_{id}+x_{ijkd}\left(s_{id}+t_{ij}\right)+\left(1-x_{ijkd}\right)\ast T\ge a_{jd} \forall \left(i,j\right)\in A:j\ge 1,k\in K,d\in D$$

(11)

$$a_{id}+w_{id}\ast \left(s_{id}+t_{i0}\right)\ge 0 \forall i\in N,d\in D$$

(12)

$$a_{id}+w_{id}\ast \left(s_{id}+t_{i0}\right)\le T\ast w_{id} \forall i\in N,d\in D$$

(13)

$$a_{i{d}_{\alpha }}-a_{i{d}_{\beta }}\le L+T\ast \left(2-w_{i{d}_{\alpha }}-w_{i{d}_{\beta }}\right) \forall d_{\alpha },d_{\beta }\in D:d_{\alpha }\ne d_{\beta },i\in N$$

(14)

$$a_{i{d}_{\beta }}-a_{i{d}_{\alpha }}\le L+T\ast \left(2-w_{i{d}_{\alpha }}-w_{i{d}_{\beta }}\right) \forall d_{\alpha },d_{\beta }\in D:d_{\alpha }\ne d_{\beta },i\in N$$

(15)

$$x_{ijkd}\in \left\{0,1\right\} \forall i,j\in V, k\in K,d\in D$$

(16)

$$y_{ikd}\in \left\{0,1\right\} \forall i\in N,k\in K,d\in D$$

(17)

$$a_{id}\ge 0 \forall i\in N,d\in D$$

(18)

The objective function of Model (1) is to minimize the vehicle travel time. This metric differs from the total duration of the route by not considering the time dedicated to customer service. Constraints (2) ensure that each driver must start the route at the depot and travel to the first customer. Constraints (3) imply that every driver must serve at least one customer each day of the planning horizon. Constraints (3) require that all routes start simultaneously (time 0 as a reference). Constraints (4) determine that if a customer requires service on a particular day, then this will be fulfilled. Constraints (5) imply that the total amount of products demanded by customers served on each route must be at most the vehicle’s capacity. Constraints (6) and (7) determine that each customer has a single predecessor and successor on the route. Constraints (8) and (9) control that each customer requiring multiple services during the planning horizon is served by the same driver.

Constraints (10) and (11) determine the arrival times for each customer on each day of the planning horizon and imply that the driver must immediately move to the next node after serving a customer. Constraints (12) and (13) ensure that the duration of any route is, at most, the maximum operating time. Constraints (14) and (15) determine that every customer requesting service on multiple days must be served with a maximum difference of $L$ units of time between different days of the planning horizon. Therefore, it is necessary to determine the service schedule for each customer on each day of the planning horizon. Constraints (16) and (17) limit the domain of the decision variables $x_{ijkd}$ and $y_{ikd}$ to binary values, and constraint (18) ensures non-negativity in the values of $a_{id}$.

3.2. Proposed Solution Method

This section describes the proposed heuristic method to solve the ConVRPms. The first section describes the main characteristics and general algorithmic structure. In subsequent sections, each of the components is described in detail.

3.2.1. Description of the Proposed Algorithm

The proposed tabu search-based repair and improvement (TSRI) algorithm is a deterministic heuristic designed to solve the problem of consistent vehicle routing with minimum service (ConVRPms). The TSRI algorithm integrates construction heuristics and procedures based on a tabu search metaheuristic [26] to produce high-quality solutions within short computing times. The theoretical complexity of the proposed approach is O(n³) because local searches based on 2-opt moves indicate that the computing time of the algorithm grows cubically with the input size. However, the architecture of the former allows high-quality solutions to be obtained within short computing times.

The algorithm has a sequential structure of four stages focused on constructing an initial solution, obtaining a complete solution, addressing infeasible solutions, and reducing the total cost of the routes. Figure 1 shows a representative process diagram of the TSRI algorithm, indicating the applied techniques and the minimum expected results for each stage.

Let $Heuristic$ be the algorithm used, $\lambda$ be the value of the respective heuristics-controlled parameter, $nRep$ be the limit of the number of iterations of the repair process, and $nMej$ be the number of iterations in the improvement process. The pseudocode of the TSRI algorithm is presented below:

Pseudocode 1. Proposed TSRI Algorithm

Procedure TSRI ($Instance$, $Heuristic$, $\lambda$, $nRep$, $nMej$)         $S\leftarrow$ Construct_solution($Instance$, $Heuristic$, $\lambda$)         If $demand is not completely satisfied$ then               $S\leftarrow$ Schedule_unsatisfied_demand($S$)         If $s is not feasible$then                  $S\leftarrow$ Repair_solution($nRep,S$)         If $s is feasible$then             $S\leftarrow$ Improve_solution($nMej,S$)                 Output: $S$ $\leftarrow$Feasible Solution         Else                 Output:  $S$ $\leftarrow$Infeasible Solution Return $S$

3.2.2. Stage 1: Constructing an Initial Solution

The first stage of the TSRI algorithm consists of constructing an initial solution. For the construction of the VRP, adaptations of classic heuristics, the savings heuristic of [27], and two insertion heuristics [28], are used. Ref. [28] stated that the savings heuristic produces higher-quality solutions for the VRP. On the other hand, Ref. [29] highlighted the effectiveness of the best insertion heuristic to generate feasible and low-cost solutions.

Savings Heuristic

The savings method of [27] was the first heuristic adapted to generate the initial solution. This adaptation is based on the version proposed by [9] to generate feasible initial solutions for the ConVRP. This adaptation presents substantial differences because the ConVRPms approach does not allow for unlimited vehicles.

The fundamental idea of the savings heuristic is constructing a solution using the repeated union of routes to obtain the maximum objective function reduction for each iteration. In this case, the objective function is the total travel time of the vehicles. The first procedure generates an initial route for each customer daily. The same vehicle is assigned to all the routes of the same customer to satisfy the consistency constraint of the DC driver. Then, for each iteration, the potential route junctions for each pair of vehicles are modeled, and the respective savings are calculated. Four different union types, referred to as movements, have been proposed.

Let $k$ and $l$ be two vehicles that serve at least one customer for the current solution. ${\alpha }_{kd}$ and ${\alpha }_{ld}$ are the first customers served by the respective vehicles on day $d$, and ${\omega }_{kd}$ and ${\omega }_{ld}$ are the last served customers. The four movements used to join the routes of these two vehicles are as follows:

• The route of vehicle l is inserted after the route of vehicle k

  $\underset{\_}{[{\alpha }_{kd},\dots , {\omega }_{kd}]}$	$\underset{\_}{\left[{\alpha }_{ld},\dots , {\omega }_{ld}\right]}$	$⟹$	$\underset{\_}{\left[{\alpha }_{kd},\dots , {\omega }_{kd},{\alpha }_{ld},\dots , {\omega }_{ld}\right]}$	$\forall d\in D: y_{0kd}=1$
  Route $k$ of the day $d$	Route $l$ of the day $d$		New route of day $d$

• The route of vehicle l is inserted before the route of vehicle k

  $\underset{\_}{\left[{\alpha }_{kd},\dots , {\omega }_{kd}\right]}$	$\underset{\_}{\left[{\alpha }_{ld},\dots , {\omega }_{ld}\right]}$	$⟹$	$\underset{\_}{\left[{\alpha }_{ld},\dots , {\omega }_{ld},{\alpha }_{kd},\dots , {\omega }_{kd}\right]}$	$\forall d\in D: y_{0kd}=1$
  Route $k$ of the day $d$	Route $l$ of the day $d$		New route of day $d$

• The inverse route of vehicle l is inserted after the route of vehicle k

  $\underset{\_}{\left[{\alpha }_{kd},\dots , {\omega }_{kd}\right]}$	$\underset{\_}{\left[{\omega }_{ld},\dots , {\alpha }_{ld}\right]}$	$⟹$	$\underset{\_}{\left[{\alpha }_{kd},\dots , {\omega }_{kd},{\omega }_{ld},\dots , {\alpha }_{ld}\right]}$	$\forall d\in D: y_{0kd}=1$
  Route $k$ of the day $d$	Inverse Route $l$ of the day $d$		New route of day $d$

• The route of vehicle l is inserted after the inverse route of vehicle k

  $\underset{\_}{\left[{\omega }_{kd},\dots , {\alpha }_{kd}\right]}$	$\underset{\_}{\left[{\alpha }_{ld},\dots , {\omega }_{ld}\right]}$	$⟹$	$\underset{\_}{\left[{\omega }_{kd},\dots , {\alpha }_{kd},{\alpha }_{ld},\dots , {\omega }_{ld}\right]}$	$\forall d\in D: y_{0kd}=1$
  Inverse Route $k$ of the day $d$	Route $l$ of the day $d$		New route of day $d$

Then, the total net savings are calculated from the union of the routes of k and l by means of the respective move m according to (19):

$$s_{kldm}=\left\{\begin{array}{c}{\lambda }_A\left(t_{{\omega }_{kd}0}+t_{{\alpha }_{ld}0}\right)-t_{{\omega }_{kd}{\alpha }_{ld}} if m=1 \wedge y_{0kd}=y_{0ld}=1\\ {\lambda }_A\left(t_{{\alpha }_{kd}0}+t_{{\omega }_{ld}0}\right)-t_{{\alpha }_{kd}{\omega }_{ld}} if m=2 \wedge y_{0kd}=y_{0ld}=1\\ {\lambda }_A\left(t_{{\omega }_{kd}0}+t_{{\omega }_{ld}0}\right)-t_{{\omega }_{kd}{\omega }_{ld}} if m=3 \wedge y_{0kd}=y_{0ld}=1\\ {\lambda }_A\left(t_{{\alpha }_{kd}0}+t_{{\alpha }_{ld}0}\right)-t_{{\alpha }_{kd}{\alpha }_{ld}} if m=4 \wedge y_{0kd}=y_{0ld}=1\\ 0 Otherwise\end{array}\right.$$

(19)

The total net savings for the planning horizon are as follows:

$$S_{klm}=\sum _{d\in D}{s}_{kldm}$$

(20)

${\lambda }_A$ is a parameter that controls the relative weight between savings and costs incurred in the union of two routes. For values greater than 1, the connections between nodes farthest from the depot are prioritized. With values lower than 1, the connections between customers closest to the depot are prioritized.

Each joint is identified by the pair of vehicles involved and the type of movement. The joints are arranged in decreasing order of total savings $S_{klm}$, and then, the feasibility of the joints is evaluated in an orderly manner. The feasibility of each connection is evaluated by calculating the total load and route duration and the arrival time for each served customer on each day of the planning horizon. Suppose that all routes of vehicle $k$ must transport a load less than the maximum capacity $Q$, have a shorter duration than $T$, and serve every customer with a difference of at most $L$ units of time between arrival times. In that case, the union is feasible, and the solution is updated. In the opposite case, the subsequent union on the list is evaluated.

The initial heuristic ends once it is impossible to perform another union feasibly or if it is possible to serve all customers with $K$ vehicles. Considering that the heuristic starts with $\left|N\right|$ vehicles, it is possible that the number of routes cannot be served with the available fleet. In this case, the routes of daily deliveries are eliminated. If the number of vehicles used continues to exceed the available fleet, the routes that serve the fewest customers are removed. Unserved customers are addressed in stage 2 of the TSRI algorithm.

Parallel Insertion Heuristic

Insertion heuristics consist of the construction of an initial solution through the repeated inclusion of one customer at a time. In the present work, two variants of the insertion heuristic are proposed. The parallel insertion heuristic differs from its sequential alternative by evaluating the insertion of each remaining customer in the routes of all available vehicles. The heuristic of parallel insertion includes two processes: the initialization of the routes and the insertion of customers. All routes are initialized prior to the insertion of customers to satisfy the empty route constraint (14) and build potentially more economical solutions by generating dispersed initial routes, thus avoiding the inclusion of the most expensive arcs. Therefore, $\left|K\right|$ nodes belonging to the set of $NI$ customers that demand service every day and that maximize the total distance between them and their distances to the depot are selected. Figure 2 shows an example of an insertion heuristic.

After the routes’ initialization, the remaining customers’ insertion process begins. Given that the ConVRP is a multiday problem, all position configurations in which each customer can be inserted are evaluated. The consistency constraint of the DC driver limits the search space by defining the insertion operator consisting of the driver.

The insertion operator consisting of a DC driver includes the selection of a customer $j$ belonging to the set of remaining nodes $RN$ and its insertion in the route of a vehicle $k$ on each day $d$ that the customer $j$ demands service ($d\in D:w_{jd}=1$). There are multiple position configurations for each remaining customer to be inserted. The position is defined using the subsequent nodes $p_{kd}$ that would be served immediately after $j$ in the routes of vehicle $k$ for each day $d$, in which customer $j$ requests service as a reference.

Once all the potential DC insertion operations are identified, the total cost of each operation is calculated. Let $p_{kd}$ be the node after the insertion of $j$ in the route of vehicle $k$ on day $d$. $s_{kd}$ is the node served before $p_{kd}$ in the current solution. The net cost of the insertion ${c_{jdp}}_{kd}$ of customer $j$ on day $d$ between nodes $s_{kd}$ and $p_{kd}$ is defined by the following expression (21):

$$c_{jd{p}_{kd} }=\left\{\begin{array}{c}{\lambda }_P\left(t_{s_{kd}j}+t_{j{p}_{kd}}\right)-t_{s_{kd}{p}_{kd}}, if w_{jd}=1\\ 0, Otherwise\end{array}\right. \forall d\in D$$

(21)

The total cost associated with the insertion is the sum of its daily net costs.

$$c_{j,p_{k1},p_{k2},\dots ,p_{k\left|D\right|}}=\sum _{d\in D}{c}_{jd{p}_{kd}}$$

(22)

The parameter ${\lambda }_P$ controls the relative weight between the cost and the savings generated from the insertion. For values of ${\lambda }_P$ greater than 1, insertions between nearby nodes are prioritized, whereas for values of ${\lambda }_P$ less than 1, insertions between distant nodes are prioritized.

The insertions are arranged in ascending order concerning total cost, and their feasibility is evaluated. The evaluation is carried out in the same way as in the savings heuristic. It is carried out upon identifying a feasible insertion, and another iteration of the insertion process is executed. The heuristic ends when all customers have been included or if it is impossible to include an additional customer without violating any constraint. Figure 3 shows an example of an insertion operator for DC. For the insertion operator, a customer is removed from route A and inserted into route B at the best location, minimizing the total travel cost (Figure 3).

Sequential Insertion Heuristic

There are specific differences between the sequential insertion heuristic and its parallel alternative. The main difference is the insertion process; only the DC insertions in the routes of a single vehicle are modeled and evaluated. As a result, a procedure is included to select the vehicle for sequential insertion.

The initialization of the routes is carried out in the same way as in the parallel insertion heuristic. The vehicle selection procedure is applied after the initialization of the routes, and on each occasion, it is impossible to insert another customer in the routes of the current vehicle. The criterion used to select the vehicle for the subsequent insertion is the minimization of the total distance between the node initially served by the vehicle and the set of customers not included in the current routes $RN$. Let $RK$ be the set of vehicles not previously selected; vehicle $k$ can be identified by evaluating the following expression for each $k\in RK$.

$$\underset{k\in \mathit{RK}}{\min }\sum _{j\in N}(y_{jkd}\ast \sum _{i\in RN}\sum _{d\in D}{w}_{id}\ast t_{ji})$$

(23)

In the insertion process, only the DC insertions in the routes of $k$ are modeled and evaluated. Once all the insertion operations for vehicle $k$ have been identified, the total cost for each operation is calculated. Analogous to calculating the total cost with the parallel insertion heuristic, a parameter ${\lambda }_S$ is incorporated to control the relative weight between the cost of the new arcs and the savings generated with each operation.

Let $p_{kd}$ be the node after the insertion of $j$ on the route of the selected vehicle $k$ on $d$. $s_{kd}$ is the node served before $p_{kd}$ in the current solution. The net cost of the insertion $c_{jd{p}_{\widehat{k}d}}$ of customer $j$ on day $d$ between nodes $s_{kd}$ and $p_{kd}$ is given by

$$c_{jd{p}_{\widehat{k}d}}=\left\{\begin{array}{c}{\lambda }_S\left(t_{s_{\widehat{k}d}j}+t_{j{p}_{\widehat{k}d}}\right)-t\_s_{\widehat{k}d}{p}_{\widehat{k}d}\\ 0, e.o.c.\end{array}\right. \forall d\in D$$

(24)

The total cost of insertion in the planning horizon is calculated via the following equation:

$$C_{j{,p}_{\widehat{k}1},p_{\widehat{k}2},\dots ,p_{\widehat{k}\left|D\right|}}=\sum _{d\in D}{c}_{jd{p}_{\widehat{k}d}}$$

(25)

After the operation and ordering costs are calculated according to the total cost, the operations are evaluated to search for a feasible insertion. When it is impossible to add another customer to the routes of the currently selected vehicle $k$, the vehicle selection procedure is applied. The sequential insertion heuristic ends when all customers have been included in the routes or if there are no additional vehicles to select ($RK=Ø$).

3.2.3. Stage 2: Scheduling Unsatisfied Demands

Stage 2 of the TSRI algorithm consists of a simple local search process that aims to schedule the remaining customers in the routes of an incomplete initial solution. For each iteration of the completion process, a new solution $s_n$ is produced that better satisfies the individual demands of a customer in its routes than the previous solution $s_{n-1}$. Indeed, given that the neighborhood $NC\left(s_{n-1}\right)$ of $s_{n-1}$ exclusively includes all the DC insertion operations of a customer not served in the solution $s_{n-1}$. Note that all the operators seek the best improvement of the following current objective function:

$$N_C\left(s\right)=N_{insertion}\left(s\right)$$

(26)

The objective function of the local search has been designed to minimize the number of violated constraints and, in the background, the value of the objective function of the problem. Let ${\sigma }_{load}^s$ be the number of routes whose load exceeds the vehicle’s capacity in solution $s$, ${\sigma }_{min}^s$ be the number of empty routes, ${\sigma }_{dur}^s$ be the number of routes whose duration exceeds the time limit, and ${\sigma }_{atc}^s$ be the number of customers whose service schedules are inconsistent. The following expression defines the objective function $f_C\left(s\right)$ of the local search.

$$\underset{s\in N_C\left(s_n\right)}{\min }{f}_C\left(s\right)={\sigma }_{load}^s+{\sigma }_{min}^s+{\sigma }_{dur}^s+{\sigma }_{atc}^s+\sum _{i,j,k,d}{\displaystyle \frac{x_{ijkd}^s\ast t_{ij}}{t_{ij}}}$$

(27)

Let $s_0$ be the initial solution; the completion process is represented by the following pseudocode:

Pseudocode 2. Proposed Completion Process Algorithm

Procedure completion (schedule with unsatisfied demand $s_0$)         $RN\leftarrow$ Unsatisfied customers in $s_0$         For $n\in 1:\left|RN\right|$            $s_n\leftarrow$ Local_search($f_C\left(s\right)$, $N_C\left(s_{n-1}\right),$ $s_{n-1}$) Return Complete solution: $s_n$

3.2.4. Stage 3: Repairing the Solution

The third stage of the TSRI algorithm consists of a process based on the tabu search metaheuristic, whose objective is to obtain a feasible solution through the progressive reduction of the number and type of violations. The repair process comprises three subprocesses: repairing empty routes or routes with excessive loads, repairing routes with excessive duration, and repairing routes with inconsistent arrival times. Each subprocess mentioned above has a neighborhood structure and a distinctive objective function.

The resulting solution in each iteration of the repair process is recorded in the tabu list, prohibiting the selection of the same solution again in a subsequent iteration. Let $N\left(s_n\right)$ be the neighborhood of $s_n$ and ${TL}_n$ be the set of solutions belonging to the tabu list in iteration $n$ of the repair process. The allowed neighborhood $\widehat{N}(s_n)$ is the subset of solutions that can be selected such that $\widehat{N}(s_n)=N(s_n) \backslash {TL}_n$. The tabu list is restarted at the end of each repair thread.

Repairing Empty or Overloaded Routes

This subprocess is applied if a load of at least one route exceeds the vehicle’s capacity or if at least one driver serves no customer on any given day. The DC repositioning and inter-route exchange operators define the neighborhood structure of the local search in this subprocess. Representations of these operations are presented in Figure 4.

$$N_{R1}\left(s\right)=N_{relocate}\left(s\right)\cup N_{interchange}\left(s\right)$$

(28)

The objective function of the local search penalizes solutions with load and minimum service violations. Let $BigM$ be a very large number ($BigM>4·\left|K\right|·\left|D\right|+2·\left|N\right||$); then, the objective function of the local search in the subprocess of repairing empty routes or with excessive loads $f_{R1}\left(s\right)$ is presented below:

$$\underset{s\in {\widehat{N}}_{R1}\left(s_n\right)}{\min }{f}_{R1}\left(s\right)=BigM\ast ({\sigma }_{load}^s+{\sigma }_{ms}^s)+{\sigma }_{dur}^s+{\sigma }_{atc}^s+\sum _{ijkd}{\displaystyle \frac{x_{ijkd}^s\ast t_{ij}}{t_{ij}}}$$

(29)

The subprocess ends when every route serves at least one customer and when the transported load is less than or equal to the capacity of vehicle $\left({\sigma }_{load}^{s_n}+{\sigma }_{ms}^{s_n}=0\right).$

Repair Routes with Excessive Duration

The second repair subprocess is applied if at least one route violates the maximum duration constraint. The structure of the neighborhood has been defined through the DC repositioning of the 2-opt intraroute and inter-route operators.

$$N_{R2}\left(s\right)=N_{relocation}\left(s\right)\cup N_{single-2opt}\left(s\right)\cup N_{exchange}\left(s\right)$$

(30)

The initial solution must respect the maximum load and minimum service constraints, and the violation of these constraints is penalized in the objective function, thus avoiding going backward in the general objective of the repair process. Let $duratio{n}_{kd}^s$ be the duration of the route served by driver $k$ on day $d$ in solution $s$; then, the objective function of the second subprocess is defined below.

$$\underset{s\in {\widehat{N}}_{R2}\left(s_n\right)}{\min }{f}_{R2}\left(s\right)=BigM\ast ({\sigma }_{load}^s+{\sigma }_{ms}^s)+{\sigma }_{atc}^s+{\sigma }_{dur}^s\ast \left[1+\sum _{kd}{\displaystyle \frac{{\left(duratio{n}_{kd}^s\right)}^2}{T^2}}\right]$$

(31)

The objective function prioritizes the solutions that minimize the number of duration violations and ATC violations. The function accompanying ${\sigma }_{dur}^s$ always returns a value between 1 and 2. It is used to avoid the reduction of the duration of some routes at the expense of the increase in others with already excessive durations. The subprocess ends when no route serves any customer, carries a load greater than $Q$, or has a duration greater than $T\left({\sigma }_{dur}^{s_n}+{\sigma }_{load}^{s_n}+{\sigma }_{min}^{s_n}=0\right)$.

Repairing Inconsistent Arrival Times

This subprocess is applied if all the constraints of the solution are satisfied except for the consistency of arrival times. The structure of the neighborhood has been defined through DC repositioning, inter-route interchange, and 2-opt multiroute operators. Please see Figure 5.

$$N_{R3}\left(s\right)=N_{relocation}\left(s\right)\cup N_{multi-2opt}\left(s\right)\cup N_{exchange}\left(s\right)$$

(32)

The objective function is designed to progressively reduce the number of ATC violations until a feasible solution is achieved.

$$\underset{s\in {\widehat{N}}_{R3}\left(s_n\right)}{\min }{f}_{R3}\left(s\right)=BigM\ast ({\sigma }_{load}^s+{\sigma }_{ms}^s+{\sigma }_{dur}^s)+{\sigma }_{atc}^s+\sum _i{\displaystyle \frac{{\left({atc}_i^s\right)}^2}{T^2}}$$

(33)

The sum at the end of the expression prioritizes the selection of solutions whose customers are served with highly consistent schedules and penalizes solutions with irregular schedules (${atc}_i^s>L>0$). Let $nRep$ be the limit of iterations of the repair process. The pseudocode of the complete repair process is presented below:

Pseudocode 3. Proposed repair procedure

Procedure Repair Procedure (Non-feasible solution, $s_0$, $nRep$)         $n\leftarrow$ 0         ${TL}_0\leftarrow$ $\left\{s_0\right\}$         While $\left({\sigma }_{load}^s+{\sigma }_{ms}^s>0\right) \mathsf{\Lambda }(n<nRep$) do                   $n\leftarrow$ $n+1$                   $s_n$← Local_search($f_{R1}\left(s\right)$, $N_{R1}\left(s_{n-1}\right)$, ${TL}_{n-1}$)                 ${TL}_n$ ← ${TL}_{n-1}\cup \left\{s_n\right\}$         ${TL}_n$ ← $\left\{s_n\right\}$         While $\left({\sigma }_{load}^s+{\sigma }_{ms}^s+{\sigma }_{dur}^s>0\right) \mathsf{\Lambda }(n<nRep$) do                   $n\leftarrow$ $n+1$                   $s_n$← Local_search($f_{R2}\left(s\right)$, $N_{R2}\left(s_{n-1}\right)$, ${TL}_{n-1}$)                 ${TL}_n$ ← ${TL}_{n-1}\cup \left\{s_n\right\}$         ${TL}_n$ ← $\left\{s_n\right\}$         While $\left({\sigma }_{load}^s+{\sigma }_{ms}^s+{\sigma }_{dur}^s+{\sigma }_{atc}^s>0\right) \mathsf{\Lambda }(n<nRep$) do                   $n\leftarrow$ $n+1$                   $s_n$← Local_search($f_{R3}\left(s\right)$, $N_{R3}\left(s_{n-1}\right)$, ${TL}_{n-1}$)                 ${TL}_n$ ← ${TL}_{n-1}\cup \left\{s_n\right\}$         ${TL}_n$ ← $\left\{s_n\right\}$         Finalize Repair process         If ${(\sigma }_{load}^s+{\sigma }_{ms}^s+{\sigma }_{dur}^s+{\sigma }_{atc}^s=0)$then                 Output: Feasible solution: $s_n$         Else                 Output: Infeasible solution: $s_n$         Return $s_n$

The repairing procedure is a tabu search-based iterative process designed to reduce constraint violations in an initially infeasible solution, progressively. Following the structure of the TSRI algorithm, the procedure is divided into three sequential subprocesses, each addressing a specific type of violation through a dedicated local search. Tabu search principles guide these local searches and operate over well-defined neighborhood structures. A tabu list $TL$ is used in each subprocess to record recently visited solutions and avoid cycling; this list is reset between subprocesses to encourage exploration of distinct regions of the solution space.

• The neighborhood N_R1 is defined by DC repositioning and inter-route exchange operators and is focused on eliminating empty or overloaded routes.
• The neighborhood N_R2 addresses violations related to excessive route durations, incorporating DC repositioning, 2-opt intraroute operators, and inter-route operators.
• The neighborhood N_R3 is designed to correct inconsistencies in customer arrival times and includes DC repositioning, inter-route exchange, and 2-opt multiroute operators.

In each stage, the local search explores the non-tabu neighborhood to find the best admissible solution, either by reducing the number of violations or increasing the overall cost. At the end of the process, the best solution identified across all stages is returned—ideally, a fully feasible solution ready for subsequent improvement.

3.2.5. Stage 4: Improving the Solution

The last stage of the TSRI algorithm consists of an improvement process based on the tabu search metaheuristic, whose objective is to reduce the total displacement time of the final solution. An approach has been designed to efficiently exploit the local search in the space of feasible solutions and guide the search to subspaces of higher-quality solutions through trajectories in infeasible solutions. This approach is applied through the objective function of local search $f_M\left(s\right)$.

Let $f_z\left(s\right)$ be a function equivalent to the objective function of the original mathematical model (1) and let $s$ be the feasible solution with the lowest value of $f_z\left(s\right)$ found thus far. Then, $z_{subopt}$ is a binary auxiliary variable that indicates whether the solution $s$ has a value of $f_z\left(s\right)$ equal to or greater than $f_z\left(s_{best}\right)$.

$$f_z\left(s\right)=\sum _{ijkd}{x}_{ijkd}^s\ast t_{ij}$$

(34)

$$z_{subopt}\left(s,s_{best}\right)=\left\{\begin{array}{c}1, if f_z\left(s\right)\ge f_z\left(s_{best}\right)\\ 0, if f_z\left(s\right)<f_z\left(s_{best}\right)\end{array}\right.$$

(35)

$$f_{inf}\left(s\right)={\sigma }_{load}^s+{\sigma }_{ms}^s+{\sigma }_{dur}^s\ast \left(1+\sum _{kd}{\displaystyle \frac{{\left(duratio{n}_{kd}^s\right)}^2}{T^2}}\right)+{\sigma }_{atc}^s\ast (1+\sum _i{\displaystyle \frac{{\left(at{c}_i^s\right)}^2}{T^2}})$$

(36)

The objective function $f_M\left(s\right)$ of the local search is presented below:

$$\underset{s\in {\widehat{N}}_M}{\mathit{min}}{f}_M\left(s\right)=f_z\left(s\right)+BigM\ast f_{inf}\left(s\right)+Big{M}^2\ast z_{subopt}(s,s_{best})$$

(37)

The structure of the neighborhood in the improvement process is defined by the DC repositioning operators: 2-opt intraroute and inter-route interchange.

$$N_M\left(s\right)=N_{relocation}\left(s\right)\cup N_{single-2opt}\cup N_{exchange}$$

(38)

Pseudocode 4. Proposed Improving Procedure

Procedure Improving Procedure (Feasible Solution, $s_0$, $nMej$)         $n\leftarrow$ 0         $s_{best}\leftarrow$ $s_0$         ${TL}_0\leftarrow$ $\left\{s_0\right\}$         While $n<nMej$ do                 $\mathrm{ }n\leftarrow$ $n+1$                 $\mathrm{ }{s}_n$← Local_search($f_M\left(s\right)$, $f_z\left(s_{best}\right),$ $N_M\left(s_{n-1}\right)$, ${TL}_{n-1}$)                 $\mathrm{ }$If $f_M\left(s_n\right)<f_z\left(s_{best}\right)$ then                 $\mathrm{ }{s}_{best}\leftarrow$ $s_n$         ${TL}_n$ ← ${TL}_{n-1}\cup \left\{s_n\right\}$ Output: Feasible solution: $s_{best}$ Return $s_n$

The final stage of the TSRI algorithm corresponds to improving a feasible solution through a tabu search-based local search. Unlike the previous repair stage, which focuses on constraint satisfaction, this phase assumes a feasible input solution and aims to minimize travel time across all routes. The improvement procedure uses the same metaheuristic structure but shifts the objective function toward solution cost rather than feasibility.

The search is conducted within a neighborhood $N_M$, defined by DC repositioning, 2-opt intraroute, and inter-route exchange operators. These moves are applied iteratively to explore increasingly better configurations of the existing solution. A tabu list $TL$ is maintained throughout the process to prevent revisiting recently explored solutions. The algorithm is executed for a fixed number of iterations, defined by the parameter $nMej$.

4. Computational Experiments

4.1. Experimental Environment and Hardware

The TSRI algorithm was implemented in the Julia programming language (version 1.6.1) through Visual Studio (version 1.58.2). The experiments were carried out on a computer with a Windows 10 Home 64-bit operating system, 16 gigabytes of RAM, an Intel Core i5-8300H @ 2.3 GHz quad-core processor, and eight threads. For study purposes, only one thread of the processor was used.

As a reference, the CPUmark score of this processor is 7543. In contrast, the processor used by Barros et al. [3] (Intel Xeon E5-2660 v2 @ 2.20 GHz) to solve the test instances through CPLEX has a CPUmark score of 10,409, and ten threads of the processor are used in parallel.

4.2. ConVRPM Test Instances

The instances of the problem applied in the experiments correspond to the structured instances from [3], which were synthetically designed to analyze the performance of the model against changes in the size of the instance, the geographical distribution of customers, the location of the depot, and the required level of consistency in arrival times. The set includes 33 instances whose sizes $N$ vary between 10, 15, and 20 customers, and the geographical distribution of these customers can be uniform or in agglomerations. The depot can be located in the center or corner of the plane, and the value of the parameter $L$, which determines the consistency in the required arrival times, can take values of 1, 3, and T, the latter corresponding to the total relaxation of the ATC constraint.

Each instance has a planning horizon $D$ of three days and a fleet of two or three $K$ vehicles with a homogeneous capacity $Q$ of fifteen units. The individual demand of each customer $q_{id}$ varies uniformly between zero and three units each day, and the service time $s_{id}$ varies between zero and two time units. The locations of the customers and the depot were determined within a square plane of dimensions 10 × 10 units in length. The parameter $t_{ij}$ was determined by calculating the Euclidean distance between each pair of nodes and then transforming the distance into units of time with a ratio of 1:1.

4.3. First Experiment

The first experiment consisted of the execution of the first two stages of the TSRI algorithm—construction and completion—to identify the values of the parameters ${\lambda }_A$, ${\lambda }_P$, and ${\lambda }_s$ that produce a more significant proportion of feasible solutions, and to analyze the efficiency of the first two stages of the algorithm in obtaining feasible solutions for different subsets of the instances, which were segmented according to the consistency in arrival times needed.

For each adapted constructive heuristic (savings, parallel insertion, and sequential insertion), 41 scenarios in which the value of the corresponding controlled parameter $\lambda$ varied were defined. An initial solution was built and completed for each of the 33 instances in each scenario. The values of ${\lambda }_A$, ${\lambda }_P$, and ${\lambda }_s$ varied between 0.00 and 2.00 at regular intervals of 0.05.

In the first section, the results of the first experiment are presented. First, the populations of solutions generated in each scenario were analyzed, and the $\lambda$ values that produced the best initial solutions with each constructive heuristic were identified. Then, the proportion of feasible solutions of the scenarios with the best-observed performance was analyzed by segmenting the instances according to the consistency in the required arrival times.

Figure 6 contains a set of three scatter plots in which the proportion of feasible solutions and the average lower-bound BKS of the population of feasible solutions produced in each scenario of the first experiment are shown.

The number of feasible solutions and their quality are sensitive to the variation in the value of the corresponding parameter $\lambda$ of each constructed heuristic, and no scenario results in a proportion of feasible solutions of 100%.

The maximum proportion of feasible solutions observed when applying the savings heuristic was 60.6 percent, equivalent to 20 feasible solutions of 33 total solutions when ${\lambda }_A$ equaled 1.05. The average lower-bound BKS of the feasible solutions in this scenario was 7.8%. The maximum proportion of feasible solutions observed in the scenarios in which the parallel insertion heuristic was applied was 66.7%, with ${\lambda }_P$ values equal to 0.65, 0.70, and 1.85. The average BKS observed in these three scenarios was 8.4%, with ${\lambda }_P$ equal to 0.65. Finally, the maximum proportion of feasible solutions observed when applying the sequential insertion heuristic was 69.7 percent, obtained with values of ${\lambda }_S$ equal to 0.85, 0.95, 1.40, 1.45, and 1.50. The lowest average BKS limit observed in these scenarios was 24.0%, which was obtained with ${\lambda }_S$ equal to 0.85.

Figure 7 shows the proportions of feasible solutions of the scenarios with ${\lambda }_A$, ${\lambda }_P$, and ${\lambda }_s$ equal to 1.05, 0.65, and 0.85, respectively, in different subsets of the test instances, which were segmented according to the level of requirement of the ATC constraint.

The three heuristics produced initial feasible solutions in one third of the instances, with $L$ equal to 1. The proportion of feasible solutions increased considerably for the instances with values of $L$ equal to 3 or $T$. However, the construction heuristics and the completion process needed to be revised to obtain feasible solutions for all instances, even for the segment with the ATC constraint, which was relaxed. Finally, each solution produced in the first experiment was constructed and completed in an average of 0.20 s, without a significant difference when different heuristics were used.

4.4. Second Experiment

The second experiment consists of executing the four stages of the TSRI algorithm in the set of test instances in different scenarios. The observed values of $\lambda$ that produced the highest proportion of feasible solutions and the lowest average lower-bound BKS in the first experiment were used. The parameter $nRep$, which determines the limit number of iterations of the repair process, was set at 250. In each scenario, one of the different variants of the TSRI was used, and the value of the parameter $nMej$ equaled zero, ten, or fifty, which determines the number of iterations of the improvement process.

Let $Var$ be the set of variants $\{1=TSRI-A,2=TSRI-P,3=TSRI-S\}$ and $Mej$ be the set of explored values of $nMej=\{0,10,50\}$, whose combination defines the scenarios of the second experiment. Let $E$ be the set of stages of the TSRI algorithm $\{1=Construction, 2=Completion, 3=Repair, 4=Improvement$} and $I$ be the set of test instances $\{1,2\dots ,32,33\}$. The following set of variables was measured for each solution at the end of each stage of the TSRI algorithm in each scenario of the second experiment.

• Feasibility of the solution: ${Fact}_{ievn}\in \{0,1\}$
• Completeness of the solution: ${Comp}_{ievn}\in \{0,1\}$
• Cost value of the solution: $z_{ievn}=f_z\left(s\right)$
• Total computing time: ${T.CPU}_{ievn}$

Then, for each solution, the relative bound of the cost $z_{ievn}$ was calculated concerning the highest lower bound obtained with CPLEX (${LB}_n$) and its relative bound concerning the most economically feasible solution known for the corresponding instance (${BKS}_n$).

$$GA{P}_{ievn}^{LB}={\displaystyle \frac{z_{ievn}-L{B}_i}{L{B}_i}}\ast 100\% \forall i\in I,e\in E,v\in Var, n\in Mej$$

(39)

$$Ga{p}_{ievn}^{BKS}={\displaystyle \frac{z_{ievn}-BK{S}_i}{BK{S}_i}}\ast 100\% \forall i\in I,e\in E,v\in Var,n\in Mej$$

(40)

The values of ${LB}_n$ and ${BKS}_n$ are provided in the comparative tables of the final solutions (see Appendix Section).

The statistical parameters used to analyze the performance of the algorithm in the solution of the set of test instances are calculated from the following expressions:

$$Avg{LB}_{evn}={\displaystyle \frac{\sum _{i\in I}GA{P}_{ievn}^{LB}\ast {Fact}_{ievn}}{\sum _{i\in I}{Fact}_{ievn}}} \forall e\in E,v\in Var,n\in Mej$$

(41)

$$Avg{BKS}_{evn}={\displaystyle \frac{\sum _{i\in I}Ga{p}_{ievn}^{BKS}\ast {Fact}_{ievn}}{\sum _{i\in I}{Fact}_{ievn}}} \forall e\in E,v\in Var,n\in Mej$$

(42)

$$Avg{T.CPU}_{evn}={\displaystyle \frac{\sum _{i\in I}{T.CPU}_{ievn}\ast {Fact}_{ievn}}{\sum _{i\in I}{Fact}_{ievn}}} \forall e\in E,v\in Var,n\in Mej$$

(43)

$$\%{Fact}_{evn}={\displaystyle \frac{\sum _{i\in I}{Fact}_{ievn}}{\sum _{i\in I}1}}\ast 100\% \forall e\in E,v\in Var,n\in Mej$$

(44)

$$\%{FactBKS}_{evn}={\displaystyle \frac{\sum _{i\in I}{Fact}_{ievn i\in I:(z_{ievn}\le {BKS}_i)}}{\sum _{i\in I}1}}\ast 100\% \forall e\in E,v\in Var,n\in Mej$$

(45)

$$\%{NoFactBKS}_{evn}={\displaystyle \frac{\sum _{i\in I}{({Comp}_{ievn}-Fact}_{ievn) }}{\sum _{i\in I}1}}\ast 100\% \forall e\in E,v\in Var,n\in Mej$$

(46)

$${\left(Desv{BKS}_{evn}\right)}^2={\displaystyle \frac{\sum _{i\in I}{{(Ga{p}_{ievn}^{BKS}-AvgBKS}_{evn })}^2\ast {Fact}_{ievn}}{\sum _{i\in I}{Fact}_{ievn}}}$$

(47)

Next, the results of the second experiment are presented. First, the final solutions obtained for each experimental scenario were described and analyzed. The individual contribution of each stage of the TSRI algorithm for the set of instances was analyzed. The performance of the TSRI algorithm was compared with the experimental results reported by [3], and the performance of the different variants of the TSRI algorithm in different segments of the set of instances was compared. Finally, the best new solutions discovered for structured instances were identified.

Table 1. Statistics of the final solutions.

Scenario		Population Parameters		Parameters of the Subset of Feasible Solutions
Variant (Heuristic)	$\mathit{n}\mathit{M}\mathit{e}\mathit{j}$	% Feasible Solutions	$\% \mathbf{Feasible} \mathbf{Sol}: \mathit{z}\le \mathit{B}\mathit{K}\mathit{S}$	Average Lower-Bound BKS	Deviation Lower-Bound BKS	Average Lower Bound	Average CPU Time [s]
TSRI—A	0	97.0%	15.2%	10.0%	10.3%	23.0%	12.94
TSRI—A	10	97.0%	51.5%	3.3%	6.5%	15.3%	26.02
TSRI—A	50	97.0%	60.6%	2.0%	4.1%	13.9%	119.20
TSRI—P	0	100.0%	3.0%	10.5%	10.5%	23.4%	9.38
TSRI—P	10	100.0%	39.4%	4.3%	8.3%	16.2%	20.18
TSRI—P	50	100.0%	60.6%	2.1%	5.2%	13.7%	101.63
TSRI—S	0	100.0%	3.0%	20.7%	14.6%	34.1%	10.55
TSRI—S	10	100.0%	39.4%	4.7%	6.3%	16.6%	19.40
TSRI—S	50	100.0%	51.5%	2.9%	5.1%	14.3%	105.96

Source: owner.

shows a set of statistical parameters of the population of final solutions obtained in each scenario of the second experiment.

All the final solutions obtained with the P and S variants of the TSRI algorithm were feasible. In all the scenarios corresponding to variant A, the proportion of feasible solutions was 97.0%, which was equivalent to one infeasible solution of thirty-three total solutions. The proportion of feasible solutions with a cost z less than or equal to the cost of the best-known BKS solution was greater than 50 percent in all scenarios with fifty iterations of the improvement process and ten iterations when applying variant A of the TSRI algorithm.

The solutions generated in the scenarios with $nMej$ equal to 50 or 10 had a lower average value of $GA{P}_{ievn}^{LB}$ and $Ga{p}_{ievn}^{BKS}$ and a lower standard deviation of ${BKS}_{evn}$ ($Desv{BKS}_{evn})$than the solutions obtained in scenarios with a lower number of iterations. The average computing time with $nMej=50$ approximately quintupled the average computing time with $nMej=10$, and the latter approximately doubled the average computing time with zero iterations of the improvement process. The average computing times required to obtain a feasible solution with variants A, P, and S of the TSRI algorithm were 12.94, 9.38, and 10.55 s, respectively. When comparing the three variants in the scenarios with $nMej$ equal to 50, the TSRI-P variant produced a population of 100% feasible solutions with the lowest average values of $GA{P}_{ievn}^{LB}$, $Ga{p}_{ievn}^{BKS}$, and total computing time.

Table 2. New Best-Known Solutions (BKS).

					$\mathit{n}\mathit{I}\mathit{m}\mathit{p}=50$
Id	Inst.	CPLEX Branch-and-Cut			TSRI—A		TSRI—P		TSRI—S
		LB	z (BKS)	T.CPU [s]	z	T.CPU [s]	z	T.CPU [s]	z	T.CPU [s]
6	20UC1	109.84	159.07	3600.00	156.50	211.14	152.62	214.44	154.94	208.57
8	20CC1	70.43	98.93	3600.00	100.39	216.08	93.52	208.41	93.52	182.41
9	20CE1	135.23	165.47	3600.00	165.50	225.36	165.07	182.30	168.62	185.05

Source: Owner.

shows the costs (z) and total computing time (T.CPU) of the solutions generated with the different variants of the TSRI algorithm and the solutions obtained via CPLEX in Barros et al. (2020) [3] for instances 6, 8, and 9.

At least one feasible solution was discovered with a cost z lower than the BKS for each instance. The best solutions were obtained with the P variant of the TSRI algorithm. Instances 6, 8, and 9 belong to the set of instances with 20 customers and with a maximum demand in the arrival times ($L$ equal to 1). Appendix section shows the graphical representation of the new best solutions discovered and the solutions obtained via CPLEX in Barros et al. (2020) [3] for instances 6, 8, and 9, respectively.

Figure 8 shows the $Avg{LB}_{evn}$, $Avg{BKS}_{evn}$, and average computing time T.CPU of the final solutions generated with each variant of the TSRI algorithm and the solutions generated by the CPLEX branch-and-cut approach in Barros et al. (2020) [3].

The feasible solutions produced with the three variants of the TSRI algorithm were observed to have a higher average $Avg{BKS}_{evn}$ than those obtained with CPLEX. On average, the solutions generated with the TSRI-P variant had a cost z 2.1 percent higher than the BKS cost of the best-known solutions obtained through CPLEX. The average BKS limit is slightly lower with the TSRI-A variant; however, not all solutions were feasible with this variant. A significant difference was observed between the average computing time of the TSRI algorithm and the average observed time of the exact method. The TSRI-P variant with 50 iterations of the improvement process took 101.6 s on average to deliver each final solution, in contrast to the 1535.9 s of CPLEX. Figure 9 shows the average computing times of the TSRI-P and CPLEX B and C variants in different instances, segmented according to the number of customers or the consistency in arrival times needed.

The average computing time observed with CPLEX was 12 s greater than that of the TSRI-P in the instances with ten customers. This difference increased to 1130 s in the instances with fifteen customers and 2898 s with twenty customers. When segmenting the instances according to the value of the parameter $L$, it is possible to observe that both methods took longer to compute the solutions with $L$ equal to 1. The average T.CPU observed with the TSRI-P algorithm was lower for the instances with $L$ equal to 3. In contrast, CPLEX took less time to compute the solutions with a fully relaxed ATC constraint ($L$ equal to $T$). Figure 10 shows three statistics of the solutions generated with the TSRI-P variant and $nMej=50$ at the end of each of the four stages of the TSRI algorithm: construction, completion, repair, and improvement.

At the end of Stage 1 of the TSRI algorithm, feasible solutions were obtained for a fraction of the total test instances. At the end of the second stage, all the solutions were feasible or infeasible. At the end of the third stage, all the solutions were feasible. At the end of the fourth and final stages, the solutions had a lower average BKS than those obtained at the end of the third stage (repair stage). Finally, the feasible solutions obtained at the end of the fourth and final stages had a lower $Avg{BKS}_{evn}$ than those obtained at the end of the repair stage.

Figure 11 shows the $Avg{BKS}_{evn}$ of the final solutions for different subsets of the test instances, segmented according to the size of the instance, the distribution of customers, the location of the depot, or the consistency in arrival times needed. The solutions corresponding to instance 3 (15UC1) were excluded because the TSRI variant produced an infeasible solution.

The TSRI—A variant (savings heuristic) generated solutions of higher quality than the other two variants in the instances with the depot located in the center of the plane and the instances with a very tight or relaxed ATC constraint ($L \in \{1,T\}$). When segmenting according to the customers’ geographical distribution, the $P$ variant (parallel insertion) performed better than the other two variants did in instances with uniformly distributed customers and customers distributed in clusters. It also produced more economical solutions in instances with a moderate ATC requirement ($L=3$). Finally, the $S$ variant (sequential insertion) performs better in instances with 15 or 20 customers and where the depot is located in the plane’s corner.

5. Discussion of the Results

The experimental results demonstrated the competitiveness of the TSRI algorithm over CPLEX in terms of the solution of the structured instances of the ConVRPms, generating high-quality solutions in a computing time considerably less than those reported in the literature. When comparing the solutions produced with the TSRI-P variant, the average cost was 2.1 percent higher than those generated with CPLEX. It was computed in a time equivalent to 6.6% of the average value observed with the exact method. In addition, it produced higher-quality solutions in some of the largest and time-restricted instances.

It is important to consider the disparity in the hardware used to process the solutions in the present investigation and the study carried out by [3]. It is expected that more iterations of the repair and improvement processes could be processed in less computing time with comparable resources. The main competitive advantage of the proposed method over the exact method is its speed, which is reflected in the observed computing times. The difference in the performance of both methods increased with increasing problem size and arrival time demand. In contrast, the inability to evaluate the quality of the solutions is a weakness of many heuristic methods, including the TSRI algorithm. Compared with the costs reported by [3], some solutions were up to 5.5% less expensive, and others were up to 23.6% more expensive.

Each variant of the TSRI algorithm performed better than its alternatives in terms of the quality of solutions generated in different segments of the set of instances. In conjunction with the relatively low computing times of the first two stages (construction and remaining demand schedule) compared with those of the last two stages (repair and improvement), the evaluation of multiple initial candidate solutions could considerably improve the quality of the final solution at the expense of a marginal increase in computing time. Other methodologies proposed in the literature for the solution of VRPs with consistency considerations incorporate the evaluation of multiple initial solutions prior to the metaheuristic components. The stages of the TSRI algorithm were effective in achieving their objectives. The adapted constructive heuristics could generate feasible solutions in more than half of the instances, the repair process made almost all programs with violated constraints feasible, and the improvement process considerably reduced the cost of the routes. Another relevant finding is that the TSRI algorithm took approximately 10 s to generate a first feasible solution, considerably less than the approximate 92 s required for CPLEX. The main limitation of the proposed approach is the lack of benchmarking instances for comparing efficiency. Different variants of the ConVRP have been proposed, and each one is tested on a different set of instances. Therefore, comparing effectiveness is difficult. The proposed approach has been compared with the instances proposed by [3] and CPLEX. Another limitation is related to the parameterization of the proposed approach, which affects the performance of the results.

6. Concluding Remarks

Compared with other routing problems focused exclusively on cost minimization, the methods proposed in the literature review for solving the vehicle routing problem with consistency considerations stand out for their complex algorithmic structures. These problems are challenging to solve because time consistency constraints are imposed to improve customer satisfaction.

This paper proposes a heuristic algorithm for the Consistent Vehicle Routing Problem with Minimum Service (ConVRPms). The proposed algorithm is based on classical CVRP constructive heuristics and the tabu search metaheuristic. The results show the effectiveness of the proposed method for performing feasibly, with low-cost solutions and short computing times considerably lower than those observed with CPLEX, successfully fulfilling the general objective of the present study.

The TSRI algorithm is introduced as a competitive solution methodology for the ConVRPms, which is capable of optimally solving instances with 20 customers and a three-day planning horizon, and producing better solutions than CPLEX for some large instances and the hourly consistency needed. The proposed approach could be extended to solve other variants of the ConVRP with some minor changes related to the parameters of the tabu search.

For future research, the following is proposed:

• The adaptation of the TSRI algorithm for the solution of other variants of the ConVRP, its application for sets of instances of medium size, and the comparison of its performance concerning other heuristic methods.
• The incorporation of an initial phase for which multiple candidate solutions are evaluated and the incorporation of random elements within the improvement process on the basis of tabu search.
• A matheuristic solution method, which incorporates the TSRI algorithm as a higher bounding procedure, is developed prior to applying an optimization algorithm, such as branch-and-cut.
• The performance of population-based algorithms for solving ConVRPms is high for some variants of other well-known combinatorial problems ([30,31,32,33,34,35]) to compare the performance with that of the proposed TSRI.