2.1 Approaches for large orienteering problems and use of partitioning methods

There exist a number of different solutions approaches for OPs (e.g., see [1] for an overview), accounting for a diversity of formulations, objectives, and constraints. Here, we review selected works specifically addressing the suitability of an approach for efficiently tackling large OP instances. We also specifically review existing work that is based on or relies on data partitioning, similar to our data decomposition using clustering. Note that the qualitative assessment of the performance of each algorithm is done referring to the benchmark set and the computational experiments of the EA4OP paper [19], which we use as reference in the experiments reported in Sec. 4.

Silberholz et al. [21] propose a Two-Parameter Iterative Algorithm (2-P IA) for the General Orienteering Problem (GOP), which is is an OP where each candidate point is assigned a number of scores for different attributes and the overall function to optimize is a function of these attribute scores. The results of OPs solved using the 2-P IA heuristic show that, while the algorithm is very competitive in regards to solution quality, its computation time does grow drastically, and impractically, for large instances with one thousand points and more, which is a common pattern for existing heuristic approaches.

Remarkable examples of heuristics for OPs include GRASP with Path Relinking (GRASP-PR) [22] and the evolutionary algorithm EA4OP proposed by Kobeaga et al. [19]. Similar to 2-P IA, these heuristics are able to produce near-optimal solutions, but with a computation time that increases significantly for large instances, which is especially the case for GRASP-PR. The incorporation of any of these algorithms into our metaheuristic is expected to result in a large decrease in computational time accompanied by only a small decrease in solution quality. We have assessed this for the case of EA4OP (given that the code was publicly available).

Santini [23] proposed a heuristic based on the Adaptive Linear Neighbourhood Search (ALNS) algorithm. The heuristic starts off with an initial solution and iteratively destroys and repairs the solutions using different destroy methods, such as random and cluster remove methods, and different repair methods, such as a greedy and cluster repair methods. A local search method is optionally executed on the solution after it is destroyed and repaired to further improve it. The best feasible solution is then chosen. The reported experimental results for this heuristic show that it outperforms other heuristics, including the EA4OP that we use in this work, in many instances, but it has a worse time efficiency than EA4OP for large instances. High-quality yet relatively inefficient heuristics such as the one in [23] are suitable candidates to plug into our clustering metaheuristic. Note that we have chosen to use EA4OP heuristic as a reference here given the availability of the source code and its relatively simple(r) structure.

Gavalas et al. [24] have proposed two cluster-based improvements to Iterative Local Search in team-orienteering problems. The two methods proposed are called: Randomized Cluster Ratio (RCR) and Cluster Search Cluster Routes (CSCR). CSCR enforces that all nodes in a cluster are visited before moving to the next cluster. One the other hand, RCR makes it such that it is preferable to stay within one cluster until all of its nodes are visited. In principle, these heuristic for local serach could be incorporated into out metaheuristic to possibly boost the local search phase, at the expenses of extra computational costs.

Sylejmani et al. [25] consider a scenario where paths for a group of tourists have to be obtained and model this problem as a TOP. In this instance, however, tourists have heterogeneous preferences for the available tourist sites. Additionally, a tourist’s utility from visiting a site depends on who are the specific tourists visiting that site at the same time, based on a metric of social relations. The authors propose to cluster the tourists based on their closeness to each other, where closeness is measured as the Euclidean distance in a 4-dimensional space of different attributes. The members of each cluster are assigned the route of their cluster’s centroid. This approach departs from the scenarios that we are focusing on since it considers a specific class of TOP scenarios.

Archetti et. al. [26] formulate and propose a heuristic solution for the Set Orienteering Problem (SOP), a cluster-based generalization of the OP. In a SOP, candidate points are grouped into clusters and each cluster has a utility score associated with it. The utility of a cluster is gained by the orienteering agent if it visits at least one candidate point in that cluster. The proposed heuristic solution approach is based on Tabu Search [27]. Again, while the proposed solution is interesting in terms of using a clustering approach, it departs from the scenarios that we consider here since in this case it is enough to visit one point to clear one cluster.

On the side of exact algorithms for the OP, one reference is the Branch-and-Cut (B&C) algorithm proposed by Fischetti et al. [28]. From results reported in [19], we can see that (as expected) the algorithm’s computation time explodes for larger OP instances. The popular Gurobi solver offers a flexible standard interface for tackling OPs. In general, all the exact algorithms get slow when confronting a large instance, but are indeed relatively fast on solving small instances. In our metaheuristic we aim to exploit this fact, by automatically decomposing the input problem into small sub-problems that can be quickly solved to optimality by standard / optimized exact solvers. In this way we can reuse what is readily available, making it able to scale up its applicability to large(r) problems.

The idea of using clustering in the input space or, more generally, data partitioning has been applied to different types of routing problems, including different versions of the Travelling Salesman Problem (TSP) and of the OP, both for single and multi-agent cases. It is worth noticing that the OP is related to the Selective TSP [29].

In the case of the Clustered Travelling Salesman Problem (CTSP) [30], the notion of clustering is part of the problem definition itself. In an N-city CTSP, not only should each city point be visited exactly once, but subsets (clusters) of these cities must be visited contiguously. In a recent paper, Anaya et al. [31] proposed a solving the CTSP is by breaking up a TSP into smaller independent TSPs. The proposed solution utilizes a combination and modification of the heuristic NEH [32] and of the metaheuristic Multi Restart Iterated Local Search (MRSILS) [33]. After each sub-problem is solved, the solutions are joined with the aim of minimizing the total cost of the path. In [31], joining sub-solutions into one final solution is done by connecting each sub-solution to the closest sub-solution available. In our metaheuristic, we follow a similar approach, but instead of using a greedy solution-connecting procedure, we join sub-solutions through a TSP procedure that is better able to minimize the path cost of the overall solution and ensure overall feasibility. Moreover, we set the number of sub-problems and identify them in a fully automatic way (through K-medians clustering).

Another type of Clustered Traveling Salesman problem is the General Traveling Salesman Problem (GTSP) where the salesman is presented with a set of clusters and the goal is to visit exactly one vertex in each cluster. Karapetyan et al. [34] proposed a Lin-Kernighan heuristic for the GTSP. GTSP is quite a different problem from ours.

Angelelli et al. [35] address a generalization of the OP, which they call the Clustered Orienteering Problem (COP). A COP consists of clusters of customers that an agent must visit. A pre-determined reward is obtained when the orienteering agent visits all costumers in a cluster. This paper proposes two solution approaches, an exact solution approach, which is a branch-and-cut algorithm, and a heuristic algorithm based on a tabu search scheme.

Decomposing a TSP into smaller TSPs, similarly to what we do for an OP, is proposed by Deng et al. [36–38]. In [36, 37], K-means [39] clustering is used. On the other hand, affinity propagation [40] is used in [38]. We prefer to use K-medians [41] over these two clustering methods because it is more robust to outliers, unlike K-means, and it allows us to determine the number of clusters, unlike affinity propagation. Note that our metaheuristic must be able to choose the number of clusters because it allows us to limit the computation time required to obtain a final solution. As we will see in following sections, we choose the number of clusters based on the time-efficiency of the algorithm used to find the paths inside the clusters. To join the cluster solution into a final solution, a nearest neighbor approach is used in [36] and a genetic algorithm in [37, 38].

Sodhi [42] proposes another clustering heuristic for solving TSPs in order to improve the Greedy and the Nearest Neighbor TSP heuristics. Here, the author utilizes the Density-Based Spatial Clustering of Applications with Noise (DBSCAN) to cluster the TSP nodes. When using the Greedy heuristic, a solution for each cluster is found and these solutions are then joined greedily. On the other hand, when using the Nearest Neighbor heuristic, a different procedure is followed: once a node is visited that is within a cluster, the nearest neighbors algorithm is restricted to nodes that are within that cluster until all nodes in that cluster are visited. In our work, we opt for using distance-based clustering instead of density-based clustering, precisely aiming to minimize the distance between members of the same cluster. In fact, having clusters in which the points are close to one another is preferable since it would result in cluster solutions with lower costs, which can allow us to visit more nodes, and therefore potentially gather higher rewards in the OP.

Finally, Gavalas et al. [24] use two cluster-based heuristic algorithms to organize the candidate sites into groups based on topological distance criteria and intelligently support the use of an Iterated Local Search. The nodes inside a cluster are explored first, and then the search sequentially moves across adjacent clusters. The algorithms are developed for the Team Orienteering Problem with Time Windows (TOPTW), which is among the most challenging classes of orienteering problems. Clustering is done based on K-means. Results are qualitatively good and computations are fast. However, only instances up to a maximum of 250 nodes are considered, which is reasonable considered the complexity of TOPTW. In our approach, apart from considering OP instead of TOPTW, a cluster is seen as a sub-problem that can be independently solved, with the solution pieces being merged in a final phase. Our approach allows us to exploit parallelism of computations and implement multiple levels of optimization.

The metaheuristic that we propose applies the concept of problem decomposition already found in the literature, however, it includes a few innovative design aspects, such as: the use of a (more) robust clustering methodology, the strategic division of the budget among the sub-problems based on estimated total reward and the capabilities of the solver at hand, a fully parallelizable way of solving the sub-problems, a general yet efficient methodology for joining the solutions of the sub-problems and adjusting the composite path to guarantee budget feasibility and maintain high solution quality.

2.2 Orienteering models for informative path planning problems

So far we have reviewed existing work from the Operations Research domain. However, as pointed out in the Introduction, orienteering models are also widely employed in mobile robotics, especially when tackling IPP problems. In these cases, the scenarios typically require setting up large OPs that have to be solved online and iteratively (e.g., for a path replanning triggered by newly acquired data and/or changes in the environment). In this context, the availability of orienteering heuristics that can handle large problems in a short, controlled computation time is essential to permit an extensive and efficient use of OP models. Indeed, the design of the metaheuristic presented in this paper has been precisely motivated by the need to solve online large IPP problems arising in the context of a research addressing the use of multi-robot systems for surveying and monitoring tasks in marine environments (research project TARMEM: Teams of aquatic and aerial robots for marine environmental monitoring, www.tarmem.org).

Unfortunately, in addition to the computational challenges, the use of standard orienteering formulations in IPP scenarios can suffer from one additional issue, which is related to the use of an additive objective function in the OP model. In fact, in typical IPP scenarios such as environmental surveying, the goal is to reduce uncertainty in the target regression model (i.e., the spatial map of the environmental attribute of interest) which is incrementally built using the measures sampled by the robot(s) at the selected locations. In such scenarios, the information provided by adjacent locations is usually correlated (e.g., water salinity won’t change dramatically from one point to its close neighbor points), such that the information provided by the measure at one location depends on the history of the other nearby sampled locations. In other words, the contribution of each measure cannot be summed up independently from the other measures. In these cases, using a standard OP formulation with a modular (additive) objective defines a model which results in an approximation of the original underlying problem, being based on the assumption of independence for the information provided by the individual sites.

A number of works have specifically addressed and incorporated the above notion of correlation in information, resulting in a departure from the basic orienteering model. Krause et al. [43] and Chekuri et al. [18] show that using an appropriate measure of information such as mutual information allows us to define efficient algorithms and theoretical bounds for the submodular orienteering problem [44] (where the objective function becomes submodular). In [45] submodularity is used in a more general multi-robot scenario where IPP is coupled with the notion of risky traversal of an edge to define a linearization procedure which leads to a greedy approximation algorithm with a constant-factor approximation guarantee. Yu et al. [12] assume correlation but do not assume submodularity. Instead, a general correlated orienteering problem is defined and formulated as a mixed integer quadratic programming, which is solved by a newly proposed algorithm. In other works [13–15], different optimization approaches have been used for tackling the IPP problem, always explicitly tackling into account the statistical correlation structure of the objective function.

The downside of these approaches accounting for a submodular objective is that the number of sites that are considered in practice for solving a correlated version of the OP is necessarily small, in the order of tens in [15, 46] and up to 150 in [12]. In other words, a large area to survey is drastically discretized into a small number of candidate locations, usually placed on a fixed regular grid, and the IPP is solved with respect to these points. Moreover, computations can still be relatively large, in the order of thousands of seconds, which is not suitable for an online setting.

These practical limitations suggest that an alternative way to tackle IPP problems can consist of using a modular approximation but coupled with the ability to solve large instances, with thousands of sites, quickly and using an iterative approach with a rolling horizon for frequent replanning. In other words, using large instances, a dense discretization can be realized, increasing the potential accuracy for selecting sites. At the same time, by exploiting the rapidity in tackling the instance, a continual replanning scheme can be in place, allowing us to account for the progressively gathered new evidence. Overall, these advantages can cancel out or reduce the impact of the approximation error introduced by the assumption of independence in the objective. An example of the effectiveness of such an approach is shown by Di Caro and Ziaullah Yousaf [16], which in turn further supports the need for fast heuristics capable of handling large OPs.

3.1 Computing the number of clusters for decomposing the input OP

The core step of the metaheuristic is the partitioning of the n input data points into N disjoint data sets, hereafter referred to as clusters since we use a clustering approach for the purpose of partitioning the input data into disjoint data sets. We will define balanced clusters, in the sense that they will include a comparatively equal amount of points . Based on this operational assumption, N is computed as a function of N_max such that the expected time that it would take for the OPS to solve an OP with N_max points is bounded by a time t_cluster. In turn, t_cluster is strategically defined as an “acceptable” time in the context of the application (e.g., a computation time of 20 seconds could be acceptable for an interval-based rolling horizon replanning for a mobile robot in a long-lasting mission).

In other words, the value N_max reflects the cost-efficiency of the OPS that we use to solve the OPs of individual clusters, where the use of more efficient solvers allows for a larger N_max. Additionally, a larger N_max is expected to result in higher-quality solutions for the global OP, since the possibly negative effects of decomposing the problem into independent sub-problems will be less evident.

Note that the definition of N_max requires some rigorous yet empirical evaluation process. In fact, to determine N_max, it is first necessary to make a strategic choice about the value of the time bound t_cluster, which depends on the application scenario. Then, t_cluster is used to make a possibly empirical assessment of the upper bound on the size of an OP (of the same class considered in the application) that the available OPS can solve within the t_cluster time bound. In our experiments we have precisely considered a data set of instances of increasing size and made a statistical evaluation of the maximum size N_max that could, on average, be solved to optimality or near-optimality within the t_cluster time using our machines.

Once N_max has been strategically defined as described above, N is set to: (1)

3.2 Computing the data clusters for each sub-problem

The computed value of N is used to decompose the data set of the input OP into N disjoint clusters. In principle, any suitable clustering technique could be used for this purpose. The existing literature is quite extensive, with different algorithms having different pros and cons [50]. In very general terms, clustering techniques can be classified as distance-based, density-based, model-based, grid-based, kernel-based, spectral-based, and hierarchical-based. For decomposing the input set of points into partitions, we need to use a method that ensures that points that are close to each other in the data space are more likely to be in the same group. This is because we need to minimize the distance cost between members of the same group in order to reduce the costs for traversing between consecutive visited sites in the final solution. This would generally allow us to find solutions with more visited sites, which are expected to have higher utility scores. Suitable algorithms for this purpose are distance-based clustering techniques, such as K-means [39] and k-medians [41], that can also run extremely fast and can be strategically tuned in terms of computation vs. accuracy balance. We eventually opted for K-medians clustering to partition the input data points because it is more stable and less sensitive to outliers compared to K-means.

The result of the clustering step is that the data of the input OP is split into N disjoint sets, C_i, i = 1, …, N, each associated with an edge-weighted graph G_i(V_i, E_i) ⊂ G(V, E) with utilities on the nodes. In turn, each G_i(V_i, E_i) defines a novel, small(er) orienteering sub-problem, S_i, i = 1, …, N.

3.3 Solving the OPs inside the N clusters

The next stage consists of solving the S_i, i = 1, …, N as independent sub-problems. The chosen OPS is used for that purpose. Modern multi-core architectures can be readily used for performing the computations in parallel, exploiting the full independence among the sub-problems.

Each S_i is defined by its associated graph G_i(V_i, E_i) but also requires a cost budget constraint B_i. In the input OP, we are given a cost budget B for the overall problem, which we can use to define a way of apportioning B over the individual sub-problems. The budget B_i allocated for a data cluster C_i should be proportional to the expected utility score that can be gained from that cluster, in order to allow us to spend more time (i.e., visit more sites) in a potentially highly rewarding cluster of points compared to a low rewarding one.

We compute the proportionality factor as follows. We first assign to each cluster C_i, i = 1, …, N a utility score (2) where |C_i| is the number of points in cluster C_i and U_i is the median utility score of points in the cluster. The normalized value of the utility score of a cluster is used to define the fraction of budget allocated for the cluster: (3)

Once each graph G_i is paired with a budget constraint B_i, it is only necessary to add start and terminal nodes to completely define a new orienteering sub-problem, S_i, over the data points in cluster C_i. As we have already pointed out, in order to fully account for application scenarios in robotics, we assume that the input OP is a rooted one, with the starting node corresponding, for instance, to the robot’s starting location, but the terminal node is open. Therefore, the S_i which includes the root node is defined as a rooted orienteering sub-problem, while all the other orienteering sub-problems are unrooted. In this latter case, a dummy node is added to play the role of starting and terminal node. The cost from/to the dummy node is set to zero, as well as the utility delivered by the node.

Each one of the N orienteering sub-problems S_i that are now fully defined is solved (to optimality or near optimality) using the OPS. Each S_i is tackled independently from the others, allowing to inherently parallelize the computations. In turn, this approach reduces the processing time for solving the input OP to little more than the time to solve the orienteering sub-problem S_i that happens to require the longest processing time.

The output from solving the N sub-problems S_i is a set (4) of N mutually disjoint paths, each resulting from the independent solution of a sub-problem S_i defined over a data cluster C_i.

3.4 Merging solutions from individual orienteering sub-problems

The next stage of the metaheuristic is about merging the N disjoint paths in P_clusters to obtain one single path which will represent a first, not necessarily feasible, solution to the original OP. We merge the paths in a way which is expected to be efficient, aiming to a successive optimization stage to improve the resulting path and make it feasible (if necessary). More specifically, we represent the problem of joining the N path solutions in P_clusters first as a Rural Postman Problem [49] (RPP) and then we approximate the RPP as an asymmetric TSP using a sampling approach.

To model the problem as an RPP, we define the graph G_merge = (V_P, E_P), where the vertex set V_P is the set of all the end-points of the paths Pⁱ, i = 1, …, N, in P_clusters: (5) where and represent, respectively, the start and the end nodes of path Pⁱ.

The edge set in E_P comprises of two subsets: E_P = E_C ⋃ E_NC. The set E_C includes all the undirected edges joining the end-points of path Pⁱ inside cluster C_i, for i = 1, …, N. Each edge has a a cost equal to the cost cⁱ of the path Pⁱ as found in the previous stage.

The set E_NC includes all the undirected edges of type with x, y ∈ {s, e} and i ≠ j, joining the end-nodes of different cluster paths. If the edge was in the initial graph G, its cost is set accordingly. Instead, if in G the two nodes were not the end-points of an edge, the cost is computed as the shortest path in G between the nodes. We have made the assumption that G is a connected graph, such that the existence of a shortest path is guaranteed. For instance, in the case of a robotic application where the nodes represents sampling points and the robot can move over continuous environment, the shortest path can be computed as the traveling distance between the two points based on the traversability of the environment and robot’s properties of holonomicity or not.

The goal is to find in the graph G_merge the path of minimum cost that joins all the edges in the subset E_C, beginning from the edge with the start node. This defines an instance of the RPP. The RPP is an arc-routing problem [49, 51] derived from the Eulerian path problem by requiring to find a minimum cost path through a subset of the edges in the graph. The RPP is NP-hard [49]. Here we tackle it with an original sampling heuristic that allows a direct control of the running times and only requires the use of standard tools for the TSP. The heuristic proceeds as follows.

We first transform the RPP problem into an asymmetric TSP. For each edge in E_C a direction is (randomly) selected, either from s to e or vice versa. Adopting a dual representation, the directed edge is converted into a vertex and the dual graph G_mergeTSP is constructed from G_merge as follows. Each edge in E_C is replaced by a vertex vⁱ. The edges that were before connected to either or become incident to vⁱ and their cost depends on the selected direction of the original edge . The process is illustrated in Fig 2, which shows, from left to right: the G_merge graph, with the costs of associated to each edge, where the undirected cluster edges (i.e., the edges representing the path inside a cluster) are represented as solid lines; a random selection of the directions for the undirected cluster edges; the dual transformed graph G_mergeTSP, where the cluster edges have been replaced by vertices vⁱ and the costs of the new edges account for the selected directions of the cluster edges.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Transformation from RPP to TSP for path merging.

(Left) The G_merge graph derived from the solution of the individual N sub-problems in P_clusters. The costs of associated to each edge are indicated. The undirected cluster edges are represented as solid lines, and different clusters are shown using different colors. (Middle) The G_merge graph with a random selection of the directions for the undirected cluster edges. (Right) The dual transformed graph G_mergeTSP, where the cluster edges have been replaced by vertices vⁱ and the costs of the new edges account for the selected directions of the cluster edges.

https://doi.org/10.1371/journal.pone.0271751.g002

For instance, based on the selected directions shown in the figure, the cost of the edge going from dual vertex v³ to v¹ includes the cost for traveling from to plus the cost for going from to .

The graph G_mergeTSP has now only N = 3 nodes and can be solved as an asymmetric TSP, which will be equivalent to find the target minimum cost path joining the N cluster edges. To remove the need for a tour and to ensure that the start point is selected as the beginning of the path, a dummy node with zero cost to/from all the other nodes is added to the G_mergeTSP graph and used to define a TSP rooted in start. A merging path can be then found accordingly using a standard TSP solver. We have used the popular Concorde https://www.math.uwaterloo.ca/tsp/concorde.html solver (by first transforming the asymmetric TSP into a symmetric one by adding nodes [52]).

Note that the number of clusters may barely go up to an order of 100 in practice. For instance, if the initial OP has size n = 10000, which is very large, and the OPS can effectively handle in a few seconds the solution of OPs with 100 nodes, we will have . Modern TSP solvers, such as Concorde, can tackle TSPs of this size in just a few seconds and output an optimal or near optimal solution.

The TSP approximation of the original RPP is based on choosing arbitrary directions for the cluster edges . In order to make an optimized selection among the multiple possible choices of edge directions, we repeat the above process by randomly sampling different edge directions. At the end of the iterations, the solution with the cheapest cost is selected. In practice, in our experiments, we stop the sampling loop after a maximum time is reached, which allows a fine control of how much time is being allotted to this processing stage.merg.

3.5 Optimize and repair the solution for budget feasibility

The solution path OP_merge found at the previous stage is potentially neither finely optimized nor budget-feasible. Being not finely optimized is the result of having first independently solved a set of sub-problems S_i, i = 1, …, N over disjoint sets of data clusters, and then merged the resulting data points in the N paths Pⁱ by only considering the end-points of the paths, and not the whole set of their points.

A simple example of the possible negative effect of the above way of proceeding is shown in Fig 3. In the left figure it is shown the optimal solution path of a simple 9-sites OP. The right figure shows the solution obtained to the same problem through the merging of the solution paths resulting from decomposing the data set in three clusters, highlighted by different colors. The points in the solution are the same but it can be noted that the (short) edge from point 1 to point 2 could not be chosen, since each cluster is solved independently and those two points are in different clusters and one of them is not an end-point. As such, the found solution locally differs from the optimal one, determining a substantial increase in cost, which in turn might make the whole solution not budget-feasible.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Pitfalls of merging only considering end-points.

(Left) Optimal solution of a 9-sites OP. (Right) Solution to the same OP obtained by first decomposing the point set into three clusters. The clusters are highlighted by the different color points. The solution path is the result of merging the solutions from the three clusters using their path end-points.

https://doi.org/10.1371/journal.pone.0271751.g003

In order to tackle the optimization of local components of the solution path OP_merge, a local search optimization procedure is executed, which outputs a path OP_LS with a possibly lower cost but same total reward compared to OP_merge. In our experiments we have chosen a 2-opt local search for that purpose, given that for the OP_merge we only aim to possibly change the order in which the sites are visited for the sake of reducing the total traveling cost of the solution, without adding or removing sites. In other words, we are dealing with the optimization of a TSP solution, and 2-opt is a fast and effective local search heuristics for TSP [53] that can be easily tuned to run within given strategic time bounds. In any case, the open design of the metaheuristic makes it possible to adopt different choices.

The solution path OP_LS resulting from the local search optimization stage can still be unfeasible with regards to the cost budget E. This is because, based on Eq (3), , we have given no allowance for the cost of inter-cluster traveling, a cost that is added at the time of merging the solutions from solving inside each cluster. This means that there is a concrete possibility that the merged and optimized solution OP_LS has a total cost that is greater than the problem’s budget B. We tackle this potential issue by running a greedy repair procedure that ensures respecting the budget constraint.

The repair procedure proceeds as follows. First, the nodes in OP_LS are sorted based on a deletion score ds, computed as the ratio between the cost that would be saved if the node is removed and the utility that would be lost if that node was removed. More precisely, the deletion score for a node i ∈ OP_LS is computed as follows, given that in the solution path the node is preceded by a node k and followed by a node j: (6) where c(x, y) indicates the cost for crossing the edge between nodes x and y, u(i) is the utility provided by node i, and c_sp is the cost for going from k to j along the path of minimal cost (which corresponds to c(k, j) if the two nodes are directly connected). Using the sorted list, the node with the maximum deletion score ds is removed from the solution path. This greedy process is repeated until the cost of the overall solution path is less then or equal to the cost budget B. Note that, in order to make the score ratio balanced between costs and utilities, both costs and utilities are normalized in a common [0, 1] range.

After the repair stage, the resulting path, OP_feasible, is ensured to be a feasible solution for the original OP.

The multiple stages of the metaheuristic are summarized below in the pseudo-code of Algorithm 1. Note that for the sake of generality, the algorithms for data clustering and for local search are passed as parameters. In our implementation they have been set, respectively, to K-medians and 2-Opt.

Algorithm 1: OP Clustering metaheuristic

Input: Orienteering problem (OP), where P is the set of candidate points and B is cost budget;

      OPS: OP solver;

      N_max: Maximum size of a cluster;

      CA: Clustering algorithm;

      LS: Local search optimizer for merging TSP.

Output: Solution path for the input OP.

  /* k is the number of data clusters */

 S ← clusterInputData(P, k, B, N_max, CA)

 /* S is a set of k orienteering sub-problems S_j, where each S_j ∈ S has at most N_max candidate points */

 for S_j in S do

  P^j ← OPS(S_j)

  /* Solve all sub-problems using OPS */

  /* If #CPUs > 1, sub-problems can be solved in parallel */

 P′ ← mergePathsWithTSPModel({P⁰, …, P^k−1})

 P″ ← improvePath(P′, LS)

 if pathIsFeasible(P″, B) then

  solutionPath ← P″

 else

  solutionPath ← repairPath(P″, B)

 return solutionPath

4.1 Clustering metaheuristic with EA4OP as heuristic solver

Tables 1 and 2 clearly show that our metaheuristic is capable of sharply attenuating the computation time of the standalone EA4OP algorithm, hereafter referred to as H_EA4OP, as the size of the OP increases. For smaller instances, which are not our primary focus, H_EA4OP might be able to compute solutions in marginally less computation times than when it is plugged into our metaheuristic, which we refer to as MH_EA4OP. As the instance size exceeds 300, the gain in computation time achieved by MH_EA4OP over H_EA4OP becomes substantial. In fact, the larger the OP instance, the greater the reduction in computation time achieved by MH_EA4OP, reaching as much as a 95% relative reduction in computation time.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Performance of EA4OP as standalone algorithm and when used in the clustering metaheuristic (Flat instances).

https://doi.org/10.1371/journal.pone.0271751.t001

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Performance of EA4OP as standalone algorithm and when used in the clustering metaheuristic (Random instances).

https://doi.org/10.1371/journal.pone.0271751.t002

On the other hand, the relative reduction in solution quality caused by using MH_EA4OP instead of H_EA4OP does not seem to be correlated, either negatively or positively, with the size of the OP instance. In fact, the reduction in solution quality, which ranges from 7% to 19% in our experiments, remains relatively flat as the size of the problem increases.

Given the difference in how ΔU and ΔT change with the increase in the OP instance size, it is evident that, the larger the size of the OP instance, the more beneficial it is to use MH_EA4OP instead of H_EA4OP. To demonstrate this more clearly, we assign a score that represents the gain achieved by using MH_EA4OP versus H_EA4OP to solve an OP instance. We define this gain score, G, as (9) A positive G score means that the decrease in computation time achieved by using MH_EA4OP instead of H_EA4OP outweighs the decrease in utility, and thus it is “beneficial” to use MH_EA4OP instead of H_EA4OP. Note that a negative value of ΔT or ΔU indicates a relative increase in computation time or solution utility, respectively, relative to the standalone algorithm. Fig 4 shows how ΔT, ΔU, and G change with the increase of the OP instance size. The two plots indicate that the gain score sharply increases with the increase of problem size. The G score then plateaus as the relative decrease in computation time approaches 100%, given that the relative decrease in utility score remains relatively flat.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. Performance of MH_EA4OP vs. H_EA4OP.

Gain achieved by using MH_EA4OP instead of H_EA4OP vs. instance sizes. (Left) OP instances with Flat utility scores. (Right) OP instances with Random utility scores.

https://doi.org/10.1371/journal.pone.0271751.g004

4.2 Clustering metaheuristic with the Gurobi exact solver

Tables 3 and 4 show the results of the experiments carried out using the Gurobi exact solver, referred to as H_G, and our metaheuristic with the Gurobi solver plugged into it, referred to as MH_G. The results in those tables should be examined while keeping in mind that, in the experiments with H_G, a maximum time for computation was set to 2 hours (7200 seconds). Additionally, a MIP gap goal was set to 0.05 (5%). This means that H_G stops computing once 2 hours has passed or once the incumbent solution reaches a MIP gap of 0.05. When using the Gurobi solver inside MH_G, computations for each cluster were interrupted either after 40 seconds of computation or when the incumbent solution inside the cluster reached a MIP gap of 0.05. Given these settings, we would expect that, for large(er) OPs, the Gurobi solver in our experiments would not be able to achieve high utility scores, even after exhausting all of the allowed computation time. As a matter of fact, for the largest instance used in the experiments, pr2392, no feasible solution was found by H_G in the given time bounds. The result of these limitations for computation times is that MH_G achieves better utility scores than H_G for the larger OP instances, which is indicated by the negative values in the ΔU column of the tables.

Download:

• PNG
  larger image
• TIFF
  original image

Table 3. Performance of Gurobi as standalone algorithm and when used in the clustering metaheuristic (Flat instances).

https://doi.org/10.1371/journal.pone.0271751.t003

Download:

• PNG
  larger image
• TIFF
  original image

Table 4. Performance of Gurobi as standalone algorithm and when used in the clustering metaheuristic (Random instances).

https://doi.org/10.1371/journal.pone.0271751.t004

ΔT for the Gurobi solver experiments remained very high for all the instances. This is due to the fact that, the less time-efficient the OP solver, the more gain is achieved by decomposing the problem into smaller sub-problems. Since the Gurobi solver can be inefficient for medium-large instances, our metaheuristic is able to achieve a very substantial computation time reduction. The gain score plots for H_G and MH_G are shown in Fig 5. In this case they look more irregular than in the EA4OP case precisely due to the fact that some values become negative.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Performance of MH_G vs. H_G.

Gain achieved by using MH_G instead of H_G vs. instance sizes. (Left) OP instances with Flat utility scores. (Right) OP instances with Random utility scores. In the upper plot, gains do not include the largest test instance, pr2392, since in this case the relative improvement using MH_G is two orders of magnitude such that data points for the other instances get flattened out. The lower plot is the same as the upper one but including the data for pr2392.

https://doi.org/10.1371/journal.pone.0271751.g005

Note that the code for the experiments reported in this paper is not parallelized. To quantify the effect of solving for the clusters in parallel, we solved the pr2932 instance with EA4OP plugged into our metaheuristic. The number of clusters computed was 96. The computation times for the clusters have an average of 0.15 seconds and a median of 0.16 seconds. To emulate the effect of solving the clusters in parallel, we randomly assigned each cluster to one of 4 CPU cores of our machine. As a result, the computation cost of the 96 clusters went down from a total of 11 seconds to only 3 seconds (72% reduction). If we had more than four cores, the reduction would be more significant, bringing ideally the whole computation time of the metaheuristic to little more the time of computing for one cluster, about 1 second in the example case, which would definitely be suitable for an online deployment.