1 Introduction
In the current sharing and ‘on demand’ economy, the number of services available and the demand for them have increased (Schor and Fitzmaurice 2015). New services, such as Uber, DiDi or GOGOVAN have emerged. One of the benefits of such a system is the ability to develop optimisation logic that increases profits for partners, and decreases the costs for customers (Nguyen, Rintamäki and Saarijärvi 2018). It is no different in logistics, where Capacitated Vehicle Routing Problem with Time Windows makes goods delivery more efficient by optimising fleets of vehicles  allowing them to deliver more parcels and helping each driver to complete more deliveries on a daily basis.
Problems such as the Travelling Salesperson Problem (TSP) or Vehicle Routing Problem (VRP) have always been given much attention in the literature. TSP was first explored by (Flood 1956) and VRP was introduced using the example of optimal routing of gasoline trucks by (Dantzig and Ramser 1959). Ever since, both of these problems have been important ones in the field of Operations Research.
In this work, we focus on solving the special case of the Vehicle Routing Problem, where customers must be served within the given time window and each of the vehicles has a limited capacity  namely the Capacitated Vehicle Routing Problem with Time Windows (CVRPTW). Vehicle Routing Problem with Time Windows was proved to be NPhard (Solomon 1986).
Throughout the time, there have been many proposed solutions to the CVRPTW. The first exact method to be proposed was the branchandbound approach(Christofides and Eilon 1969), which is the basis for the branchandcut exact algorithm (Baldacci, Hadjiconstantinou and Mingozzi 2004). However, even the current stateoftheart exact methods work only for up to 360 waypoints (Pecin et al. 2017), which is not enough in our use case.
Another approach is to use metaheuristics in order to improve a suboptimal solution. Three metaheuristics (Laporte et al. 2006)
are the most efficient: Genetic Algorithms (GA)
(Baker and Ayechew 2003) (Alba and Dorronsoro 2006) (Karakatič and Podgorelec 2015), Local Search (Cordeau, Gendreau and Laporte 1998), (Nagata and Braysy 2008) or Ant Colony Optimisation (ACO) (Gambardella, Taillard and Agazzi 1999).The most current benchmarks indicate that the method by (Pecin et al. 2017) performs the fastest, as tested for up to 1000 nodes (Uchoa et al. 2016).
There have been quite a few frameworks that are based on these algorithms, both open source and commercial. For open source solutions, there are VRPH (Groer, Golden and Wasil 2010) and Google Optimization Tools (ORtools) (Perron 2011). While for commercial solutions, Gurobi (Gurobi 2018), LocalSolver (Zhang, Qi and Miao 2015) and other Constraint Programming solvers are used.
For our work, we decided to include the use of ORtools, as it has got a Python API and it supports multiple VRP cases. In this paper, we focus on improving the performance of aforementioned framework by using a modified version of the DBSCAN clustering algorithm (Ester et al. 1996), which we refer to as ”RecursiveDBSCAN”. The reason why we decided to do so, is because the runtimes of ORtools solvers increase rapidly (Fig. 1) and also, consume a lot of RAM memory (almost 20GB for 2000 waypoints).
In the Section 2 of this paper we formally formulate our problem. Section 3 describes our proposed method, with the results being presented in Section 4 and discussed in Section 5. Section 6 proposes some future work on the problem.
2 Problem Formulation
Vehicle Routing Problem can be subjected to various constraints such as constraints on vehicle capacity and time window of arrival. We look into VRP’s particular case  Capacitated Vehicle Routing Problem with Time Windows. We can describe the problem as follows:
Goods are to be delivered to a set of delivery points by a number of vehicles departing from the central depot. The vehicles are supposed to pick up all the packages from the depot within a certain time window. Similarly, each delivery vehicle needs to arrive at each delivery point within a certain time window specific to that point. Each vehicle has a limited capacity and each delivery has a certain size.
The goal is to determine a route schedule which minimises the travelled distance, given the following constraints:

Each vehicle starts its route at the depot.

The total size of packages assigned to a particular driver cannot exceed the capacity of the vehicle.

Each delivery waypoint is to be served by one and only one vehicle.

Each delivery needs to be completed within a given time window.
There are N delivery waypoints to be visited by the maximum of M vehicles. Let’s assume that the depot is node . The size of each delivery , , is defined as , while the time window is . The pickup time at the depot is . Each vehicle , , has got a maximum capacity . We define travel time between nodes and for the vehicle as , while is the distance between nodes and for the vehicle .
As in our case, we do not force vehicles to return back to the depot, we set
We can describe the problem mathematically (Szeto, Wu and Hoc 2011) as:
(1) 
Subject to:
(2) 
(3) 
(4) 
(5) 
(6) 
(7) 
(8) 
(9) 
(10) 
where is the number of deliveries, is the number of delivery vehicles, is the arrival time of the vehicle at node and is the arrival of the vehicle at the depot.
The objective function in Eq. (1) is to minimise the total travelled distance for all the vehicles. Constraints in Eq. (3) and Eq. (4) ensure that one and only one vehicle respectively arrives at and departs from each of the nodes. Eq. (5) ensures the route continuity. Eq. (6) ensures that the total size of packages taken by a vehicle does not exceed its capacity. Eq. (7) and Eq. (8) ensure that the time windows are met. Eq. (9) and Eq. (10) make sure that each vehicle is used no more than once.
3 Method
3.1 Data Collection and Processing
The datasets are prepared from a sample of GOGOVAN trips completed in Hong Kong in 2017. They contain more than 10,000 delivery waypoints, provided in the GPS format. The datasets are randomised during the analysis.
The tests are conducted on a 2017 Macbook Pro 13”, with 2.3 GHz dualcore Intel Core i5, 16GB 2133 Mhz LPDDR3 RAM and 256GB SSD. For distance calculation, we use straightline distance.
3.2 Algorithms for Vehicle Routing Problem
We decided to present our proposed RecursiveDBSCAN solution and benchmark it against two other methods.
The first method involves passing all the waypoints and vehicles, along with the constraints to the Google Optimization Tools solver and treating its output as the final solution. The other two methods are clusteringbased approaches, where we first attempt to cluster the delivery waypoints and then try to optimise each of the clusters separately, by also passing it to the ORtools Routing solver. The second method uses classical DBSCAN, while the third one is the proposed RecursiveDBSCAN clustering approach.
3.2.1 Google Optimization Tools
As a baseline, we chose to solve the CVRPTW problem using the ORtools library.
The parameters we call Google Optimization Tool’s Routing library with every time are as follows:
Parameter  Value  Description 

first_solution_strategy  PATH_CHEAPEST_ARC  First solution strategies, used as starting point of local search. Starting from a route ”start” node, connect it to the node which produces the cheapest route segment, then extend the route by iterating on the last node added to the route. 
optimization_step  1  Minimum step by which the solution must be improved in local search. 
solution_limit  9223372036854775807  Limit to the number of solutions generated during the search. 
time_limit_ms  5000  Limit in milliseconds to the time spent in the search. 
use_light_propagation  true  Use constraints with light propagation in routing model. Extra propagation is only necessary when using depthfirst search or for models which require strong propagation to finalise the value of secondary variables. Changing this setting to true will slow down the search in most cases and increase memory consumption in all cases. 
3.2.2 Dbscan
One of the approaches explored is to use the DBSCAN clustering algorithm to cluster the waypoints to be optimised into several clusters of different size that will then be optimised one by one using the ORtools method.
We define one very important constant here  , which represents the maximum number of delivery points in each cluster. Our goal is to obtain the clusters of maximum possible average size, while each of them is smaller than the aforementioned constant. We then pass these clusters as input to the ORtools routing solver to obtain the optimised routes.
The pseudocode of such a method looks as follows:
Such a method already divides the routing problem into several smaller problems, consequently improving the performance of the algorithm.
3.2.3 RecursiveDBSCAN
We also propose a modification of the method described above, which applies DBSCAN recursively to each cluster, with the aim to make clusters more wellbalanced in terms of number of waypoints in each of them (while decreasing the spatial balance).
We use binary search to find the initial feasible radius that maximises . We then identify clusters which contain too many nodes and apply recursively the same binary search logic in order to break down those large clusters into smaller, constituent clusters. Such an approach ensures that the found final clusters are of maximum possible average size, while at the same time they all lie within the preset size boundaries.
Such a method creates clusters of large radii in the less dense regions and smaller clusters in the highdensity regions. The aim of that method is to obtain clusters that contain a similar number of waypoints and yet different radii. Such an approach resolves one issue encountered with classical DBSCAN  clusters in regions with more nodes contain more nodes than clusters in less dense regions. It also avoids a situation when a vehicle is assigned to a point within a cluster that contains only a few nodes.
We have a few constraints, namely: , and .
By reducing the variance of the number of nodes in clusters and putting constraints on both the maximum and minimum number of nodes per cluster, we obtain splits which can be effectively optimised separately, as they are smaller in terms of number of nodes. That should lead to improvement in runtimes of classical VRP solvers.
The pseudocode of the proposed can be found below:
3.3 Optimisation with ORtools call
Having already produced the clusters using either the DBSCAN or the RecursiveDBSCAN method, we have obtained clusters of delivery points ready to be optimised. We attempt to optimise clusterbycluster and with each iteration we remove vehicles marked as “busy”  which means these “busy” vehicles are not considered for assignment for other clusters.
The following pseudocode illustrates that method:
3.4 Setting of Testing Parameters
The algorithm’s final output is an optimised delivery route, a sample of which is visualised in Fig. 2.
To test the performance. we chose the batches of size between 500 and 5000 waypoints, every 500. Three different metrics were used to measure the performance: runtime, total distance of the routes and the number of vehicles that are busy. For each data point, there were 15 different tests conducted.
Also, the following parameters presented in Table 2 were used during the analysis:
Parameter  Value 

capacity of each vehicle  30 
max_cluster_size  500 
min_cluster_size  35 
min_radius  1 
max_radius  10000 
Our goal in this test was to reduce the runtime, without much impact on total distance and the number of vehicles. The ORtools result, as presented in Fig. 1., was treated as the benchmark.
4 Results
4.1 Total Travelled Distance
As can be seen in Fig. 3, for DBSCAN and RecursiveDBSCAN the distance increases linearly with the waypoints. The gradient of the RecursiveDBSCAN curve is similar to the gradient of the ORtools. DBSCAN curve increases more rapidly than both RecursiveDBSCAN and ORtools curves.
The DBSCAN curve is cut off at 2000 waypoints due to consuming more than 20GB of memory. That caused the program to crash.
4.2 Average Number of Busy Vehicles
Similarly to the Total Travelled Distance, Fig. 4. shows that ORtools and RecursiveDBSCAN increase linearly with the number of waypoints, while DBSCAN solution has got a sharp increase.
4.3 Runtime
As can be reasoned from Fig. 5., the runtimes are exponentially increasing. The RecursiveDBSCAN curve possesses the lowest gradient, followed by DBSCAN. The ORtools solution has got the greatest gradient.
4.4 Overall Performance of the Algorithms
Metric  ORtools  RecursiveDBSCAN  DBSCAN 

Total Distance  0.0%  +3.6%  +120% 
Runtime  0.0%  61%  57% 
#busy vehicles  0.0%  +6.4%  +150% 
Both RecursiveDBSCAN and DBSCAN methods lead to a significant drop in runtime. DBSCAN has large increase in total distance travelled and the number of busy vehicle as measured against ORtools. For RecursiveDBSCAN, the differences in total distance travelled and the number of busy vehicles are below 3.6% and 6.4% respectively. Summary fo results is presented in Table 3.
5 Discussion
As we can see in Fig. 3, Fig. 4, Fig. 5 and Table 3, our proposed RecursiveDBSCAN method has better runtimes than both the DBSCAN and ORtools (by ) methods. It is because RecursiveDBSCAN divides the nodeset into a lower number of clusters, which decreases the number of times the ORtools Routing library needs to be invoked. Both RecursiveDBSCAN and DBSCAN have better runtimes than ORtools as they do not have to invoke ORtools Routing library for more than max_cluster_size number of nodes.
The total distance for RecursiveDBSCAN is lower than for DBSCAN and higher than for ORtools. In terms of total distance, RecursiveDBSCAN performs better than DBSCAN because it creates less clusters, which in turn means that less vehicles are required, which leads to lower distance. However, RecursiveDBSCAN performs worse than ORtools, because it does not allow vehicles to be assigned to orders within different clusters and therefore does not take into account the relationships between the clusters.
Both the DBSCAN and the ORtools solvers would crash at 2000 waypoints due to an extreme RAM usage, while the RecursiveDBSCAN method would find solutions up to 5000 waypoints.
In summary, RecursiveDBSCAN performs better than ORtools in terms of runtime thanks to dividing the nodeset into smaller clusters, for which the optimisation results can be obtained more quickly than for the whole set being optimised at once, as the number of possible assignments and routes is greatly limited by breaking down the problem into constituent parts. Having less possible solutions to be checked means that the optimisation finishes more quickly.
At the same time, RecursiveDBSCAN performs better than DBSCAN in terms of total distance and number of vehicles used, as it simply creates less clusters than DBSCAN, which also leads to clusters containing more nodes on average. That allows the optimisation within clusters to be of better quality, as there is enough nodes to fully utilise the capacity of each vehicle.
Most importantly, the RecursiveDBSCAN method runtimes are more acceptable to be used in the ‘ondemand’ economy, as it reduces the time drivers would be required to wait compared to ORtools and supports instances of more than 2000 nodes.
6 Conclusion
This paper has described RecursiveDBSCAN  a new clustering approach to solve Capacitated Vehicle Routing Problem. By recursively clustering nodes together in batches that contain a similar number of nodes, we were able to reduce the runtimes by as benchmarked against Google Optimization Tools. That improvement is caused by splitting the nodeset into constituent parts, consequently reducing the possible number of assignments and routes. At the same time, the total distance for RecursiveDSBCAN routes was higher than for ORtools. Currently, the presented approach is used by GOGOVAN to optimise their routes on a daily basis.
We look forward to continue the work in that field. The next steps are to implement and benchmark the RecursiveDBSCAN clustering approach against some stateoftheart solvers (Uchoa et al. 2016) using the test dataset provided by (Uchoa et al. 2016) as well. We hope to observe an improvement in runtimes against the stateoftheart approaches, similarly to the improvement we have observed against Google Optimization Tools routing solver.
References
 Alba and Dorronsoro (2006) E. Alba and B. Dorronsoro. 2006. “Computing nine new bestsofar solutions for Capacitated VRP with a cellular Genetic Algorithm.” Information Processing Letters 98. 225–230.
 Baker and Ayechew (2003) Barrie M.Baker, M.A.Ayechew. 2003. “A genetic algorithm for the vehicle routing problem.” Computers & Operations Research. Vol. 30, No. 5: 787–800.
 Baldacci, Hadjiconstantinou and Mingozzi (2004) R. Baldacci, E. Hadjiconstantinou, A. Mingozz. 2004. “An Exact Algorithm for the Capacitated Vehicle Routing Problem Based on a TwoCommodity Network Flow Formulation.” Operations Research. Vol. 52, No. 5: 723–738.
 Christofides and Eilon (1969) N. Christofides, S. Eilon. 1969. “An Algorithm for the Vehicledispatching Problem.” Journal of the Operational Research Society. Vol. 20, No. 3: 309–318.
 Contardo and Martinelli (2014) Claudio Contardo and Rafael Martinelli. 2014. “A new exact algorithm for the multidepot vehicle routing problem under capacity and route length constraints.” Discrete Optimization. Vol. 12: 129–146.

Cordeau, Gendreau and Laporte (1998)
Jean‐François Cordeau, Michel Gendreau, Gilbert Laporte. 1998. “A tabu search heuristic for periodic and multi‐depot vehicle routing problems.”
Networks. Vol. 30, No. 2: 105–119.  Dantzig and Ramser (1959) G. B. Dantzig and J. H. Ramser. 1959. “The Truck Dispatching Problem.” Management Science. Vol. 6, No. 1 (October). 80–91.
 Ester et al. (1996) M. Ester, H. Kriegel, J. Sander, and X. Xu. 1996. “A densitybased algorithm for discovering clusters in large spatial databases with noise.” Proc. 2nd Int. Conf. Knowledge Discovery and Data Mining (KDD’96). 226–31.
 Gambardella, Taillard and Agazzi (1999) Luca Maria Gambardella, Éric Taillard and Giovanni Agazzi. 1999. “MACSVRPTW: A Multiple Colony System For Vehicle Routing Problems With Time Windows.” New Ideas in Optimization. 63–76. England: McGrawHill Ltd.
 Groer, Golden and Wasil (2010) Chris Groer, Bruce Golden and Edward Wasil. 2010. “A library of local search heuristics for the vehicle routing problem”. Mathematical Programming Computation. Vol. 2, No. 2: 79–101.
 Gurobi (2018) Gurobi Optimization. 2018.
 Flood (1956) Merill M. Flood. 1956. “The Travelling Salesman Problem.” Operations Research. Vol. 4, No. 1 (February): 61–75.
 Karakatič and Podgorelec (2015) S. Karakatič and V. Podgorelec. 2015. “A survey of genetic algorithms for solving multi depot vehicle routing problem.” Applied Soft Computing. Vol. 27: 519–532.
 Laporte et al. (2006) G. Laporte, M. Gendreau, J‐Y. Potvin and F. Semet. 2006. “Classical and modern heuristics for the vehicle routing problem.” Internation Transactions in Operations Research. Vol. 7, No. 45: 285–300.

Nagata and Braysy (2008)
Y. Nagata and O. Braysy. 2008. “Efficient Local Search Limitation Strategies for Vehicle Routing Problems.”
Proceeding EvoCOP’08. Proceedings of the 8th European conference on Evolutionary computation in combinatorial optimization.
. 48–60.  Nguyen, Rintamäki and Saarijärvi (2018) Hong Ngoc Nguyen, Timo Rintamäki and Hannu Saarijärvi. 2018. “Customer Value in the Sharing Economy Platform: The Airbnb Case.” Collaborative Value Cocreation in the Platform Economy. Translational Systems Sciences. Vol. 11: 225–246.
 Pecin et al. (2017) D. Pecin, A. Pessoa, M. Poggi, E. Uchoa. 2017. “Improved branchcutandprice for capacitated vehicle routing.” Integer Programming and Combinatorial Optimization. Vol. 9, No.1: 393–403.
 Perron (2011) Laurent Perron. 2011. “Operations Research and Constraint Programming at Google.” Principles and Practice of Constraint Programming – CP 2011. 2–2.
 Schor and Fitzmaurice (2015) Juliet B. Schor and Connor J. Fitzmaurice. 2015. “26. Collaborating and connecting: the emergence of the sharing economy.” Handbook of research on sustainable consumption. 410–25.
 Solomon (1986) Marius M. Solomon. 1986. “On the worst‐case performance of some heuristics for the vehicle routing and scheduling problem with time window constraints”. Networks. Vol. 16, No. 2: 161–174.
 Szeto, Wu and Hoc (2011) W. Y. Szeto, Yongzhong Wu and Sin C. Hoc. 2011. “An artificial bee colony algorithm for the capacitated vehicle routing problem.” European Journal of Operations Research. Vol. 215, No. 1: 126–135.
 Uchoa et al. (2016) E. Uchoa, D. Pecin, A. Pessoa, M. Poggi, A. Subramanian and T. Vidal. 2016. “New Benchmark Instances for the Capacitated Vehicle Routing Problem.” European Journal of Operational Research. Vol. 257, No. 3: 845–858.
 Zhang, Qi and Miao (2015) Y. Zhang, M. Qi, L. Miao and G. Wu. 2015. “A generalized multidepot vehicle routing problem with replenishment based on LocalSolver.” International Journal of Industrial Engineering Computations. Vol. 6, No. 1: 81–98.
Appendix A Testing Results
Below, we present the exact results of each CVRPTW optimisation request we have run. For data privacy reasons, unfortunately we cannot share the exact input.
#wps  runtime  runtime  runtime  distance  distance  distance  no_cars  no_cars  no_cars 

ortools  dbscan  recursive  ortools  dbscan  recursive  ortools  dbscan  recursive  
500  60  62  65  483388  516713  515871  17  18  18 
500  72  65  75  486747  507389  511661  17  18  18 
500  60  61  64  486239  515871  509121  17  18  18 
500  63  67  66  485711  500271  503640  17  18  18 
500  70  72  60  485591  499130  498963  17  18  18 
500  61  70  60  485347  498963  498963  17  18  18 
500  54  63  58  462337  469396  468921  17  18  18 
500  59  61  64  462812  470426  470782  17  18  18 
500  59  61  59  464018  470782  468593  17  18  18 
500  67  61  62  505695  477230  477230  17  18  18 
500  56  63  61  505014  477985  477230  17  18  18 
500  58  60  60  504797  477230  478540  17  18  18 
500  59  60  59  489643  536242  532264  17  18  18 
500  58  61  59  489643  535311  535799  17  18  18 
500  58  59  59  489671  535311  535311  17  18  18 
1000  346  74  74  740345  1264443  767720  34  71  38 
1000  351  86  83  740738  1264306  765552  34  71  38 
1000  290  78  70  759366  1267402  766308  34  71  38 
1000  295  67  72  725851  1460247  720003  34  89  37 
1000  316  70  85  724167  1460504  719268  34  89  37 
1000  346  74  75  725053  1460075  720048  34  89  37 
1000  402  136  139  753055  1251045  742976  34  72  36 
1000  361  118  112  753055  1257972  747099  34  72  36 
1000  483  148  137  747869  1256926  744831  34  72  36 
1000  482  122  114  714253  1650897  748432  34  97  37 
1000  489  121  113  714245  1650976  750093  34  97  37 
1000  353  125  111  719354  1651073  748446  34  97  37 
1000  288  65  65  715072  1360899  694867  34  81  37 
1000  280  65  65  715170  1360899  694407  34  81  37 
1000  281  65  65  715170  1360899  694407  34  81  37 
1500  943  201  136  922991  3175289  943656  51  198  54 
1500  957  202  135  923117  3175312  943624  51  198  54 
1500  1118  202  135  924407  3175366  943618  51  198  54 
1500  965  254  156  927529  2845066  955311  51  193  54 
1500  948  195  135  927529  2840604  955003  51  193  54 
1500  946  195  135  927529  2840025  955003  51  193  54 
1500  946  187  124  901753  2509369  945549  51  152  54 
1500  942  188  126  901679  2509369  945549  51  152  54 
1500  952  189  124  901753  2509423  945549  51  152  54 
1500  948  202  146  920773  2974830  959563  51  194  54 
1500  954  203  147  920773  2976673  959563  51  194  54 
1500  944  205  146  920773  2976102  959563  51  194  54 
1500  953  197  144  954255  2691762  1006466  51  171  55 
1500  1130  196  145  948436  2692423  1006466  51  171  55 
1500  1222  249  171  949135  2692646  1005565  51  171  55 
#wps  runtime  runtime  runtime  distance  distance  distance  no_cars  no_cars  no_cars 
ortools  dbscan  recursive  ortools  dbscan  recursive  ortools  dbscan  recursive  
2000  2738  625  371  1107218  3202771  1179192  67  198  69 
2000  2642  598  344  1106752  3203236  1175043  67  198  69 
2000  2603  643  358  1105813  3203673  1176404  67  198  69 
2000  2392  606  292  1085628  3556857  1171007  67  239  72 
2000  2415  532  297  1084229  3560283  1171322  67  239  72 
2000  2606  497  289  1084432  3559491  1171157  67  239  72 
2000  2415  572  336  1081554  3031531  1215245  67  201  70 
2000  2210  451  298  1081554  3033713  1213129  67  201  70 
2000  2237  452  301  1081554  3034193  1213188  67  201  70 
2000  2216  452  290  1071946  2919687  1125675  67  178  70 
2000  2216  450  290  1071846  2921376  1123879  67  178  70 
2000  2225  448  289  1071946  2920938  1123718  67  178  70 
2000  2222  445  271  1081664  2956164  1127928  67  186  70 
2000  2226  442  270  1081715  2956177  1127850  67  186  70 
2000  2220  443  270  1081664  2956173  1131021  67  186  70 
2500      527      1358060      89 
2500      563      1355550      89 
2500      539      1358200      89 
2500      547      1390752      89 
2500      556      1390425      89 
2500      520      1389660      89 
2500      603      1440061      86 
2500      565      1439611      86 
2500      578      1450749      86 
2500      558      1412417      88 
2500      581      1411956      88 
2500      675      1421848      88 
2500      611      1455259      89 
2500      561      1455195      89 
2500      524      1453103      89 
3000      751      1633968      107 
3000      844      1625904      107 
3000      946      1631154      107 
3000      890      1665061      107 
3000      949      1666696      107 
3000      953      1665962      107 
3000      1061      1600832      105 
3000      1077      1606483      105 
3000      947      1605001      105 
3000      938      1608125      105 
3000      932      1605236      105 
3000      900      1608508      105 
3000      784      1673911      106 
3000      746      1674320      106 
3000      752      1673882      106 
#wps  runtime  runtime  runtime  distance  distance  distance  no_cars  no_cars  no_cars 

ortools  dbscan  recursive  ortools  dbscan  recursive  ortools  dbscan  recursive  
3500      1153      1860161      123 
3500      1102      1869332      123 
3500      1081      1868842      123 
3500      1052      1813835      124 
3500      1047      1813956      124 
3500      1048      1816695      124 
3500      1105      1850848      125 
3500      1106      1850695      125 
3500      1106      1850796      125 
3500      1040      1815906      124 
3500      1040      1816712      124 
3500      1040      1815959      124 
3500      1080      1823448      122 
3500      1083      1824033      122 
3500      1078      1823337      122 
4000      1292      1999660      145 
4000      1281      1995747      145 
4000      1283      1995751      145 
4000      1315      1960920      142 
4000      1326      1961180      142 
4000      1423      1963337      142 
4000      1398      1991476      142 
4000      1344      1995379      142 
4000      1401      1991310      142 
4000      1383      2037947      141 
4000      1758      2038129      141 
4000      1446      2035300      141 
4000      1600      1966531      140 
4000      1774      1967573      140 
4000      1510      1962472      140 
4500      1828      2190689      160 
4500      1820      2192041      160 
4500      1828      2191594      160 
4500      1601      2149448      160 
4500      1603      2149016      160 
4500      1613      2150206      160 
4500      2006      2212566      160 
4500      2244      2214822      160 
4500      2040      2208680      160 
4500      1901      2198181      159 
4500      1993      2195011      159 
4500      2234      2194019      159 
4500      1986      2227280      161 
4500      1837      2225391      161 
4500      2348      2233762      161 
#wps  runtime  runtime  runtime  distance  distance  distance  no_cars  no_cars  no_cars 

ortools  dbscan  recursive  ortools  dbscan  recursive  ortools  dbscan  recursive  
5000      3127      2453175      179 
5000      2754      2446140      179 
5000      2458      2449849      179 
5000      2148      2416567      178 
5000      2230      2417642      178 
5000      2235      2417174      178 
5000      2150      2424674      179 
5000      2094      2424928      179 
5000      2081      2425004      179 
5000      2328      2419737      181 
5000      2340      2419498      181 
5000      2325      2419580      181 
5000      2112      2380606      180 
5000      2122      2379298      180 
5000      2116      2379444      180 
Comments
There are no comments yet.