Comparing CH, LS and VND

Until now, we have considered the different CH, LS and VND algorithms separately. We have also mostly neglected a very important property of the presented algorithms: their required run-time. In this section, we will analyze the trade-off between the performance of the algorithms and the required run-time. We assume knowledge of Pareto-optimality (c.f. Section 2.2.3).

Figure 6.1 shows the trade-off between lowRreland low run-time for all tested heuristics over all instances. Note that most of the CH algorithms have been cut off, since they produce far worse results than the LS and VND configurations.

The best non-dominated construction heuristics are marked by label (A). Since we are trying to solve VNMP-O, we would expect that CH-O is present. However, this is not the case. The CH configurations at (A) are just related to CH-O in the sense that they too use DLHeavyVN as SVN strategy, MostFree as IVN strategy and emphasize the implementation of virtual arcs.

The main difference to CH-O is that they use Spread-1 (faster but slightly worse) or Spread-2 as IVA strategy. CH-O itself does not occur in this graph (as Pareto-optimal CH configuration), it is dominated by the fastest LS configuration. This shows that the “best” configuration of an algorithm is not necessarily useful.

Two clusters of LS configurations are marked by (B). Since they perform on par with CHs in term of required run-time (andRrel), it is not surprising that they use first-improvement and On-lyOverloading. They employ the RemapVnode neighborhood structure. The difference between the two clusters is the initialization CH, using CH-S is faster but CH-O gives better results.

The three configurations at (C) use the ClearSarc, ClearSnode and RemapSlice neighborhood structures, still with first-improvement, OnlyOverloading and CH-O for initialization.

Marked with (D) is the first configuration using a complete neighborhood structure with Over-loadingFirst. The employed neighborhood structure is still RemapSlice, which is not surprising because it has nearly the same size whether using OnlyOverloading or OverloadingFirst. There-fore, the increase in run-time is not large. At (E), a huge improvement in performance is evident.

It is caused by switching from CH-O to CH-R as rebuilding CH. From here on out, CH-R is ex-clusively used as rebuilding strategy.

The configurations at (E) also mark the begin of a clearly visible pattern. (E) and (F) mark a group of three clusters, (G) and (H) mark a group of three clusters, and (I) and (J) (the dominated LS configurations) mark a group of three clusters. The three cluster groups represent different neighborhood structures, at (E) RemapSlice is used, at (G) RemapVnode and ClearSnode at (I).

Analyzing one cluster group further reveals that the changes in performance levels are caused by going from CH-S to CH-O as initialization heuristic and then by using best-improvement instead of first-improvement. The differences at the lowest level are caused by using Over-loadingFirst instead of None as neighborhood prioritization strategy. Putting this together, that means that for example at (G) and (H), the RemapVnode neighborhood structure is used. Start-ing from the fastest (and worst with respect toR_rel) configuration of LS, we know that it uses OverloadingFirst and CH-S for initialization. The next slower configuration switches to None.

The following increase in performance is caused by using CH-O for initialization (and going back to OverloadingFirst). The last configuration at (G) again switches to None. (H) marks the same configuration, but now using best-improvement. Since this pattern repeats itself for three different neighborhood structures, we can state with some certainty the following: Using best-improvement instead of first-improvement has a significant performance penalty for a small gain inRrel. Initial solutions created by CH-S let LS terminate earlier but with a slightly worse solution than when using CH-O. Using OverloadingFirst gives an edge with respect to required run-time while being R_rel neutral, even when using first-improvement. Note that LS-O (like

0.65

Figure 6.2: Pareto-front of the tested heuristics regarding the fraction of solved instances and run-time over all instances.

CH-O earlier) is dominated by VND configurations at (J), which achieve better results while requiring the same amount of time.

The VND configurations at (J) useC₁₂, CH-S for initialization and CH-R for rebuilding. The difference between the two Pareto-optimal configurations is once again the employed step func-tion, with first-improvement being faster but producing slightly worse results. The cluster of VND configurations at (K) usesC₉. The best configuration is VND-O.

In Figure 6.2 we present the same trade-off analysis, but now with respect to the number of solved instances. Again, most of the tested CH configurations have been cut off to focus on the interesting configurations. At (A), we see the fastest non-dominated CH configurations, which are relatives of CH-O. The difference lies just in the selected SVA strategy. (B) marks (relatives of) CH-S.

At (C), we see the fastest LS configurations. As was the case for minimizing R_rel, they use RemapSlice, first-improvement, OnlyOverloading, and initialize with CH-S. The better config-uration (in terms of solved instances) uses CH-R instead of CH-O for rebuilding. At (D), we can observe a phenomenon that did not occur previously. It marks VND configurations which are fast enough to beat LS configurations by a large margin and also achieve excellent results. Fast VND configurations could also be seen in the previous figure, but they were far worse than LS in terms of performance. The neighborhood structure configuration used at (D) isC₈. This is remarkable, since no analysis we have carried out previously indicated thatC₈is useful. Its main strength is speed, which is achieved by using three neighborhood structures in OnlyOverloading configurations. The difference in the two marked configurations at (D) is again the step-function.

After the incursion of VND, (E) and (F) mark the only complete (i.e., not using OnlyOverload-ing) neighborhood structures able to compete in terms of solved instances: RemapVnode. At (E) first-improvement is used, at (F) best-improvement.

At (G), VND is used in configurationC12, which derives its advantage in execution speed from the fact that it does not utilize the RemapVnodeTAP neighborhood structure. (H) marks a mix of different configurations, all of which use RemapVnodeTAP, also containing VND-S. The slightly faster configurations use first-improvement, the slower ones best-improvement.