Optimized Customizable Route Planning in Large Road Networks with Batch Processing

Abstract: Modern route planners such as Google Maps and Apple Maps serve millions of users worldwide, optmizing routes in large-scale road networks where fast responses are required under diverse cost metrics including travel time, fuel consumption, and toll costs. Classical algorithms like Dijkstra or A$^*$ are too slow at this scale, and while index-based techniques achieve fast queries, they are often tied to fixed metrics, making them unsuitable for dynamic conditions or user-specific metrics. Customizable approaches address this limitation by separating metric-independent preprocessing and metric-dependent customization, but they remain limited by slower query performance. Notably, Customizable Tree Labeling (CTL) was recently introduced as a promising framework that combines tree labelings with shortcut graphs. The shortcut graph enables efficient customization to different cost metrics, while tree labeling, supported by path arrays, provides fast query answering. Although CTL enables optimizing routes under different cost metrics, it still faces challenges in storing and reconstructing path information efficiently, which hinders its scalability for answering millions of queries. In this article, we build on the Customizable Tree Labeling framework to introduce new optimizations for the storage and reconstruction of path information. We develop several algorithmic variants that differ in the information retained within shortcut graphs and path arrays, offering a spectrum of trade-offs between memory usage and query performance. To further enhance scalability, we propose a batch processing strategy that shares path information across queries to eliminate redundant computation. Empirically, we have evaluated the performance of our algorithms on 13 real-world road networks. The results show that they significantly outperform state-of-the-art methods.

• The paper introduces an improved CTL framework that achieves microsecond-level route computations with up to a 15x speedup using batch processing.
• The paper details novel path storage mechanisms where the extended variant proves up to 5x faster than basic path reconstruction methods.
• The paper demonstrates that batch processing reduces redundant computations by exploiting common prefixes, enabling scalable, real-time routing in massive networks.

Optimized Customizable Route Planning in Large Road Networks with Batch Processing

Introduction and Motivation

The paper "Optimized Customizable Route Planning in Large Road Networks with Batch Processing" (2604.10608) presents a rigorous investigation and substantial improvements upon the Customizable Tree Labeling (CTL) framework for high-performance route planning in large-scale, dynamic road networks. The central challenge tackled is providing microsecond-level optimal route computation that is robust under frequent, arbitrary cost metric changes (e.g., time, distance, tolls) while maintaining scalability for millions of queries and supporting practical memory consumption. Existing customizable algorithms, while flexible with respect to edge weights, suffer from slower query performance. Moreover, efficient path reconstruction (not just distance reporting) is a significant unresolved bottleneck.

The authors address these deficiencies via: (1) novel algorithmic variants for compact path information storage in both shortcut graphs and path arrays, and (2) a batch processing scheme that identifies and exploits commonalities among query pairs for drastic computational redundancy reduction. The empirical results validate that their framework consistently outperforms previous state-of-the-art methods, notably achieving up to a 15x speedup in route computation on massive real-world networks, with memory usage remaining within practical bounds.

Figure 1: (a) Extension of the customizable route planning framework. Highlighted components in red indicate newly introduced optimizations, including advanced shortcut storage and batch processing.

Customizable Tree Labeling Framework

The CTL framework integrates the advantages of search-based (e.g., Contraction Hierarchies) and labeling-based (e.g., Hub Labeling) approaches by employing a hierarchical tree decomposition of the network alongside a shortcut graph to facilitate rapid customization and efficient queries. Unlike prior work, CTL supports parameterized labeling, enabling a fine-grained trade-off between customization effort, label size, and query latency by selectively truncating label entries at lower-hierarchy vertices.

Metric-independent preprocessing entails recursively partitioning the road network graph using balanced separators to form a tree hierarchy, from which a partial 2-hop labeling structure is derived. All shortcuts—representing direct connections along valley paths with respect to the hierarchy—are constructed in this phase. Metric-dependent customization subsequently integrates specific edge costs, populating shortcut weights and cost arrays within labels in a top-down pass.

Figure 2: Tree hierarchy and associated labeling scheme; higher-level nodes (dark blue) are untruncated, lower-level nodes (light blue) employ truncated or omitted labels for scalability.

A crucial observation underpins the parameterized approach (cf. Figure 3): vertices higher in the hierarchy (more central) are more critical for fast queries and thus retain full labels; peripheral vertices contribute less and are aggressively truncated.

Optimal Path Storage and Reconstruction Mechanisms

Path extraction—the ability to reconstruct the actual route, not merely optimal cost, between two query vertices—is a core, unsolved efficiency barrier for hierarchical customizable methods. The paper systematically explores the design space for how path information is stored and reconstructed, realizing a matrix of five viable CTL variants characterized by (i) the granularity of information retained in shortcut records (triangle node only vs. extended in-place path), and (ii) the degree of path array storage (none, endpoint-only, or extended).

• Basic shortcut storage: Only triangle (witness) nodes are maintained per shortcut, with recursive unpacking for path reconstruction, imposing significant query overhead for long paths.
• Extended shortcut storage: Full valley paths for small-enough shortcuts are stored in-place, reducing lookup and pointer-chasing.
• Path arrays: Precomputed sequences (or just successors) to the next hubs for endpoints are stored, yielding quicker endpoint chain enumeration.

Empirical analysis demonstrates that the extended path unpacking variant (CTL$_{ee}$) is up to 5x faster than basic path unpacking (CTL$_{bb}$), at the expense of increased—but practical—index size.

Figure 4: (Left) Taxonomy of CTL variants according to shortcut graph and path array choices; (Right) Query time versus index size for these variants, highlighting the decisive impact of path storage strategy.

Batch Processing Strategy

Redundant computation is prevalent in large-scale route planning: multiple queries often traverse overlapping portions of the network, especially in high-throughput services (ride-sharing, logistics). The batch processing strategy applies a prefix-sharing method—shortcut chains (endpoint–hub sequences) are lexicographically ordered, enabling common prefixes to be computed and cached only once per batch, yielding optimal work reuse.

Benchmarks reveal that batch mode reduces endpoint unpacking time by more than an order of magnitude for non-extended-path variants when the batch size is large, easily surpassing the single-query optimality barrier for practical workloads.

Figure 5: Strong diminishing of median query time as batch size increases, especially for variants where individual query path unpacking is expensive.

Figure 6: Query time by path length, underscoring the disproportionate performance advantage of extended path unpacking and batch processing on long-range queries.

Experimental Evaluation

The framework was thoroughly benchmarked on thirteen real-world, large-scale road networks—including USA and Western Europe—against CTL predecessors, Customizable Contraction Hierarchies (CCH), and Hierarchical 2-Hop (H2H) labeling. The most salient experimental findings are:

• For large networks, CTL achieves query speeds up to 13x faster than CCH and 4x faster than H2H (Europe-wide networks).
• Batch processing yields up to 98% path overlap exploited in very large batches, enabling CTL${^b}$ to outperform extended-path methods despite using more compact indices.
• Customizing to a new cost metric is efficient: CTL's customization is within a 2–4x factor of CCH, and parallelization gives near-linear speedup with core count on large graphs.
• Label size can be flexibly controlled via the $\theta$ parameter and storage choices. CTL enables a smooth time-space trade-off, making it adaptable to available memory and desired query latencies.

  Figure 7: When frequent edge updates are performed, full customization (CTL) quickly surpasses the efficiency of partially dynamic maintenance (DHL) as update count grows, making CTL robust for real-time applications.

  

  Figure 8: Metric-independent preprocessing time for CTL and CCH is dominated by tree partitioning and is similar, confirming that additional CTL features do not compromise index build throughput.

Implications and Outlook

This work consolidates customizable route planning as the paradigm of choice for large, dynamic networks where rapid metric adaptation and high-throughput, low-latency querying are mandatory. Major practical implications include:

• Scalable real-time route planning for navigation systems, logistics, and vehicle routing under heterogeneous and fluctuating metrics (traffic, carbon, costs).
• Realizable trade-offs between performance and memory via parameterized labeling and path storage configurations, making the system tunable for both high-throughput servers and embedded devices.
• Substantial reductions in redundant computation with batch answering, critical for large-scale, concurrent workloads.

Theoretically, the batch prefix-sharing scheme suggests further lines of work in caching and incremental computation for network algorithms. The analysis of the trade-offs between storage, preprocessing, and query efficiency provides new perspective for the design of hierarchical path planning oracles. Looking forward, these methods could be instrumental in multi-modal and stochastic network models, as well as distributed or federated deployment scenarios.

Conclusion

The authors provide a comprehensive, robust, and empirically validated advancement over previous customizable route planning frameworks. By engineering optimized storage and reconstruction of path information—and leveraging batch processing—the new CTL variants substantially advance the state-of-the-art, enabling microsecond-to-millisecond route computation at scale for dynamic, real-world road networks. The framework’s flexibility in time-space-resource trade-offs will facilitate its adoption in both commercial and scientific path planning systems.