**5. Results**

In the previous sections, we propose the integer linear programming (ILP) formulation and three heuristics (A, B1, and B2) to solve FQRP-G. Computational experiments have been conducted with the following purposes:


We recall that, as discussed in Section 2, previous literature approaches to collisionfree routing problems present limitations in their application to FQRP-G, since they do not consider grid-size minimization and, moreover, they allow for space-time deviations from nonstop Manhattan paths. The heuristic algorithm DA presented in [38] is able to solve FQRP-G, however it is dominated by Heuristic A for both efficiency since DA is <sup>O</sup>(*n*<sup>2</sup>) whereas Heuristic A is O(*n*), and effectiveness. Indeed, as observed in [38], DA returns routing schedules made of simple Manhattan paths on one-way horizontal lanes and, hence, compliant with the hypothesis of Corollary 1: as a consequence, DA cannot provide better solutions than Heuristic A, which is optimal under such restrictions.

In our experiments, we consider two benchmarks. The first one is made of random instances with 10 up to 300 columns and vehicles: in particular, 20 instances are generated for each *n* ∈ {10, 25, 50, 75, 100, 150, 200, 300} by randomly choosing the origin and the destination columns of each vehicle. The second benchmark includes 11 ad hoc instances with 105 up to 233 columns and vehicles, created on purpose as to contain long C-conflict paths, and more than one arborescences in the related C-conflict directed graph. ILP has also been run on a third benchmark of large random instances with *n* ∈ {350, 400, <sup>500</sup>}, to determine the larger size instances ILP can solve in practice.

All the tests were run on a workstation equipped with an Intel Xeon E-2176G processor with 6 cores at 3.7 GHz, and 16 GB RAM.

ILP has been solved using the Cplex 12.9.0 engine [44] with a time limit of 30 min. In order to take the number of variables and constraints of ILP, hence running times, as small as possible, we run Heuristic A (whose running time, as we will see, is negligible) and set the parameter *m* in the ILP model equal to the number of levels output by Heuristic A.

Table 1 reports the computational results given by ILP and Heuristic A on the first random benchmark. Statistics involving ILP refer to tests on 10 out of 20 instances available per size. The first column specifies the instance size. The average, minimum and maximum number of levels used by ILP are reported in Columns 2 and 3. ILP running times, whose average (in seconds) appears in Column 4, are below the time limit in every instance and, therefore, data in Columns 2 and 3 refer to proven optimal values. Columns 5–8 are related to Heuristic A and give respectively: the average number of levels used by its solutions, the relative percentage error with respect to the optimal ILP value, the minimum and the maximum number of levels required by all the obtained solutions, and the maximum absolute gap between the number of levels used by the solutions of Heuristic A and the corresponding optimal values. Running times of Heuristic A are not specified as they are negligible (always fairly less than 1 ms).


**Table 1.** Experimental results of ILP and Heuristic A on random instances.

The computational results given by Heuristics B1 and B2 on the first random benchmark appear in Table 2. The percentage of instances where Heuristic B1 has been able to find a feasible solution (success rate) is reported in Column 2. Columns 3 to 6 refer to these successful instances and report: the average, minimum and maximum number of levels required by B1 (Columns 3 and 5 respectively); the average per cent error in the number of levels used by B1 with respect to the optimal value output by ILP (Column 4); the maximum absolute gap between the number of levels used by B1 and the optimal values (Column 6). Always referring to successful instances for B1, Column 7 compares the performances of Heuristic B1 versus Heuristic A, reporting the percentages of successful instances in which B1 uses less (win) or more (lose) levels than A. Columns 8 to 13 report the same information for Heuristic B2. Again, statistics involving ILP refer to tests on 10 out of 20 instances available per size.

**Table 2.** Experimental results of Heuristics B1 and B2 on random instances.


ILP was able to find the optimal solution of all the instances within the time limit, and running times are consistently less than a few seconds up to 100 vehicles. For larger sizes, running time grows almost exponentially, as expected. Indeed, we performed a further test of ILP on the third benchmark, observing that only four out of ten cases with *n* = 350 (and no other larger instances) are solved to optimality. In the remaining cases with *n* = 350, ILP always finds feasible solutions whose difference with respect to the best available lower bound (optimality absolute gap) is 2.5 levels on average (maximum 4). The success rate on 400 columns instances is 90%, i.e., ILP finds feasible (even if not provably optimal) solutions for 9 out of 10 instances, with an optimality absolute gap of 3 levels on average (maximum 4). For *n* = 500, the success rate is 60%, with optimality absolute gap of 3.5 levels (maximum 4). We also observe that, as far as the third benchmark is concerned, the number of required horizontal lanes never exceeds 6 in the proposed feasible solutions.

Heuristic A is extremely fast, and, as from Table 1, it finds solutions that, even for larger random instances, take no more than 5 levels and at most 2 additional horizontal lanes with respect to the optimal values.

Running times of Heuristics B1 and B2 are negligible as well (always less than 10−<sup>2</sup> s), however, their performance is poor. Both B1 and B2 ge<sup>t</sup> stuck in all the instances with 75 or more vehicles. The success rate is acceptable only for very small instances and just, in a few cases, B1 and B2 are able to improve over Heuristic A (with B2 showing slightly better

results than B1). Summarizing the overall performance of Heuristic A on random instances is by far better than B1 and B2.

As observed above, the number of levels required by Heuristic A is very small in random instances. However, we recall that it is strictly connected to the length of the longest C-conflict path in the instance, so that, according to Equations (3) and (4), instances exist where the collision-free paths outputted by Heuristic A need more than a few horizontal lanes to be seamlessly operated. Therefore, we consider the second benchmark of ad hoc generated instances containing long C-conflict paths, more than one arborescence in the C-conflict directed graph, and further edge conflicts and B-conflicts between vehicles in the same or different arborescences. Table 3 reports the related computational results, showing a row for each instance. The number of vehicles and the length of the longest observed C-conflict path appears in Columns 1 and 2. Columns 3 and 4 give the number of levels required by the solution of Heuristic A and by the optimal solution of the ILP model, respectively. The ILP model running times, in seconds, are listed in the last column (the table does not show Heuristic A running times, since they are always less than 10−<sup>3</sup> s). Results for Heuristics B1 and B2 are not reported, since they always fail in providing feasible routes.


**Table 3.** Experimental results of ILP and Heuristic A on ad hoc instances.

ILP solves all the instances of the second benchmark to optimality, still providing routes that can be operated on a few (at most four) horizontal lanes. It is thus self-evident that Heuristic A is not appropriate to solve FQRP-G on these ad hoc instances, as it needs many more levels with respect to the optimal solution. Indeed, performing horizontal steps on more than one level is crucial, in presence of long chains of C-conflicts, to save levels. However, the ad hoc instances in the third benchmark do not appear much harder to be solved with ILP in terms of computational time.
