HLSearch: Hierarchical Shortest Path Search

• HLSearch is a hierarchical search method that partitions large graphs into subgraphs and organizes them into a multi-tier skeleton graph to support efficient shortest path queries.
• It employs SGNNs to predict inter-node distances and hop counts within each subgraph, enabling effective learned pruning and sublinear search times.
• The framework integrates local SGNN estimates with precomputed inter-access distances, achieving over 99% accuracy and rapid query performance on massive graphs.

HLSearch is the hierarchical search component of the framework introduced in "Skeleton-Guided Learning for Shortest Path Search" (Liu et al., 4 Aug 2025). It targets shortest path search on generic graphs that are too large for a single learned model, and extends LSearch by partitioning $G$ into subgraphs, training one Skeleton Graph Neural Network (SGNN) per subgraph, organizing subgraphs into a bottom-up hierarchy, and searching across partitions via learned estimates and precomputed inter-partition distances. Within the overall three-layer framework, the bottom layer builds a multi-tier skeleton graph $\mathcal G$, the middle layer trains SGNN to predict shortest-path distance $\delta(v_i,v_j)$ and hop-count $\rho(v_i,v_j)$, and the top layer executes either LSearch on moderate-size graphs or HLSearch on very large graphs (Liu et al., 4 Aug 2025).

1. Problem setting and framework position

Shortest path search is described as a core operation in graph-based applications, with three limitations motivating HLSearch. Classical algorithms such as Dijkstra's and A* become inefficient as graphs grow more complex; index-based techniques often require substantial preprocessing and storage; and recent learning-based approaches typically focus on spatial graphs and rely on context-specific features like geographic coordinates, limiting their general applicability (Liu et al., 4 Aug 2025).

HLSearch is explicitly positioned as the large-graph extension of LSearch rather than as an unrelated algorithmic family. LSearch assumes a single SGNN on the entire graph. HLSearch invokes LSearch inside leaf partitions and uses the hierarchy plus precomputed “access” distances to avoid global expansion. The framework therefore separates representation learning from global graph decomposition: the learned component remains local to subgraphs, while the hierarchy supplies the cross-partition routing structure.

A common misunderstanding is to treat HLSearch as a replacement for all shortest-path methods. The paper instead states a division of labor: LSearch applies to moderate-size graphs, whereas HLSearch applies to very large graphs. Another possible misunderstanding is to read it as a spatial-graph method. The stated design goal is broader: shortest path search on generic graphs, without requiring domain-specific features.

2. Graph partitioning and hierarchical organization

When $G=(V,E)$ is too large for a single SGNN, HLSearch first partitions $G$ into $p$ roughly balanced subgraphs $\{G_1,\dots,G_p\}$ using a standard multilevel partitioner. Seeds of highest degree initialize each block; local refinement then balances block sizes and minimizes cut edges (Liu et al., 4 Aug 2025). Each subgraph $G_i$ becomes a leaf of a tree, and adjacent subgraphs—those with inter-block edges—are recursively grouped into higher-level blocks until a single root remains.

Each node $N$ in this merge-tree stores a set of member vertices $\mathcal G$0 and a set of “access vertices” $\mathcal G$1 that connect $\mathcal G$2 to its siblings. The access-vertex abstraction is central to the hierarchy: it reduces inter-partition search to a bounded interface rather than requiring unrestricted expansion across cut edges.

Leaf and non-leaf nodes store different information. If $\mathcal G$3 is a leaf, it stores the trained SGNN for $\mathcal G$4 and the distances $\mathcal G$5, $\mathcal G$6. If $\mathcal G$7 is non-leaf, it stores, for every pair $\mathcal G$8 of its children’s access vertices, the exact $\mathcal G$9 and the associated shortest-path segment. This organization makes the hierarchy a search-time data structure rather than a trainable end-to-end differentiable stack.

The paper states that no back-prop between levels is needed: hierarchy is for search only. This is important for interpretation. It means hierarchical organization is not a multi-level GNN training pipeline; instead, it is a decomposition that constrains search and caches exact inter-access connectivity.

3. Multi-level skeleton graph

The representational basis of HLSearch is the multi-level skeleton graph $\delta(v_i,v_j)$0. Each original vertex $\delta(v_i,v_j)$1 is equipped with an $\delta(v_i,v_j)$2-tier skeleton label

$\delta(v_i,v_j)$3

where

$\delta(v_i,v_j)$4

The overall label is $\delta(v_i,v_j)$5 (Liu et al., 4 Aug 2025).

Within each $\delta(v_i,v_j)$6, bucket $\delta(v_i,v_j)$7 is linked to bucket $\delta(v_i,v_j)$8 by edges $\delta(v_i,v_j)$9 of weight $\rho(v_i,v_j)$0. The construction also connects $\rho(v_i,v_j)$1 to every label member by a “label-link” of weight $\rho(v_i,v_j)$2. The union of these links over all $\rho(v_i,v_j)$3 yields the skeleton graph.

Two structural properties are highlighted. First, any $\rho(v_i,v_j)$4-tier skeleton path from $\rho(v_i,v_j)$5 to $\rho(v_i,v_j)$6 is a subsequence of the true shortest path. Second, skeleton links at tier $\rho(v_i,v_j)$7 lie within tier $\rho(v_i,v_j)$8 labels. These properties explain why the skeleton graph can support pruning without discarding the shortest-path structure that the model is intended to estimate.

This suggests that the skeleton graph is not merely a sparsifier in the conventional sense. It is a structured encoding of hop- and distance-information across scales, with tiered bucket connectivity designed to preserve shortest-path subsequences while compressing the graph into a learning-friendly form.

4. SGNN architecture and training objectives

SGNN operates on the skeleton graph to learn node embeddings and to predict distances and hop lengths between node pairs (Liu et al., 4 Aug 2025). The input features for each $\rho(v_i,v_j)$9 include graph statistics such as degree and clustering coefficient, and label statistics for each bucket $G=(V,E)$0: $G=(V,E)$1, $G=(V,E)$2, $G=(V,E)$3, and $G=(V,E)$4.

Message-passing is performed over $G=(V,E)$5, with $G=(V,E)$6 defined as $G=(V,E)$7’s tier-$G=(V,E)$8 skeleton bucket. After $G=(V,E)$9 layers, the final embedding is $G$0. For a source-target pair $G$1, the model forms $G$2 and passes it through two separate MLPs: $G$3

The training objective is multi-task: $G$4

$G$5

The model therefore learns shortest-path distance and hop-count jointly rather than as separate models.

In the hierarchical regime, each leaf subgraph $G$6 is trained independently using only intra-block skeleton graph. After convergence, the distances $G$7 for $G$8 to its leaf-access vertices $G$9 are recorded. These are then assembled into non-leaf nodes by computing all-pairs shortest distances among child-access sets via a small Dijkstra per child-pair. The absence of cross-level back-propagation reinforces the interpretation that SGNN is a local estimator, while the hierarchy performs exact inter-access composition.

5. HLSearch query procedure

HLSearch takes as input a hierarchy $p$0, source $p$1, and target $p$2 (Liu et al., 4 Aug 2025). It first finds the leaf nodes $p$3 and $p$4 that contain $p$5 and $p$6. If $p$7, the algorithm returns LSearch on that leaf. Otherwise it computes the lowest common ancestor $p$8, identifies the child $p$9 of $\{G_1,\dots,G_p\}$0 on the path to $\{G_1,\dots,G_p\}$1 and the child $\{G_1,\dots,G_p\}$2 on the path to $\{G_1,\dots,G_p\}$3, and extracts the corresponding access sets $\{G_1,\dots,G_p\}$4 and $\{G_1,\dots,G_p\}$5.

For each $\{G_1,\dots,G_p\}$6, HLSearch computes $\{G_1,\dots,G_p\}$7 using either SGNN-based $\{G_1,\dots,G_p\}$8 when $\{G_1,\dots,G_p\}$9 is a leaf or precomputed $G_i$0 otherwise; it computes $G_i$1 analogously for $G_i$2. The pseudocode then selects an access-vertex pair $G_i$3. A plausible reading of the selection rule is that it minimizes the sum of source-to-access cost, precomputed distance between the two access vertices in the lowest common ancestor, and access-to-target cost.

Path reconstruction concatenates three segments: $G_i$4, $G_i$5, and $G_i$6. The first and third segments are obtained either by LSearch inside a leaf or by a stored leaf-access path, while the middle segment uses a precomputed Path in $G_i$7. The output is the concatenation of these three segments.

Model-driven pruning remains active through the LSearch calls used inside HLSearch. The paper states that Strategies 4.1 and 4.2 skip vertices whose partial-path cost minus predicted cost exceeds a buffered error threshold, and defer heuristic guidance until a minimum hop length $G_i$8 is reached. This design indicates that learning is used for guided pruning and local prioritization, whereas the hierarchy constrains the global routing envelope.

6. Complexity, experimental results, and interpretation

The reported time and space complexity separate construction, training, hierarchy build, and query phases (Liu et al., 4 Aug 2025). Skeleton-graph construction is

$G_i$9

for small $N$0. SGNN training per block is $N$1 per epoch, total $N$2. Hierarchy build stores inter-access distances at cost $N$3 where $N$4. Query time of HLSearch is

$N$5

with the dominant term stated as the two leaf-search calls, i.e. $N$6, since $N$7. Space is reported as $N$8 for the skeleton graph, plus $N$9 for leaf distance tables, plus higher-level access-pair storage; in practice this is linear in $\mathcal G$00.

The experiments use five real-world graphs:

Dataset	Size
Brain	503 v / 24 k e
Bio	2 k / 20 k
Web	4 k / 9 k
Power	5 k / 6 k
Road-NA	176 k / 179 k

On a test set of 10 k pairs, SGNN outperforms GNN and Node2Vec on both distance and hop prediction. The reported numbers are SGNN MAPE$\mathcal G$01 6–8% vs GNN 10–19% vs n2v 10–42%, SGNN MAPE$\mathcal G$02 4–8% vs GNN 6–18% vs n2v 8–43%, with RMSE improvements of 2–5×. On small graphs and 100 queries, LSearch reports query time 20–40 ms vs Dijkstra 14–280 ms, described as 5–10× faster, while Landmark gives 5–8 ms but uses 2–3× more memory; LSearch reports Accuracy $\mathcal G$03 and Hit-rate $\mathcal G$04 vs Landmark’s 9–70%.

For HLSearch specifically on Road-NA, the graph is partitioned into 43 blocks of $\mathcal G$05 k vertices and hierarchy depth $\mathcal G$06. The reported average query is $\mathcal G$07 ms and memory $\mathcal G$08 MB, 5× faster than Dijkstra on full graph, with Accuracy $\mathcal G$09 and Hit-rate $\mathcal G$10 over random source–target pairs up to 550 hops. The paper’s summary characterizes the resulting behavior as sublinear search time, linear storage, and $\mathcal G$11 distance accuracy on very large graphs.

Several interpretive points follow directly from these results. HLSearch is not a fully learned replacement for exact routing; it combines learned estimates, exact inter-access distances, and stored shortest-path segments. It is also not merely a partitioned Dijkstra variant; the reported gains depend on compact skeleton graphs, SGNN’s accurate distance/hop estimates, learned-pruning in LSearch, and a bottom-up partition hierarchy. Finally, the empirical evidence is not confined to road networks: the reported datasets span Brain, Bio, Web, Power, and Road-NA, which supports the claim of applicability across graph types.