---
title: Hop-Sets in Graph Algorithms
url: https://www.emergentmind.com/topics/hop-sets
type: topic
---

# Hop-Sets in Graph Algorithms

A hopset for a graph is a set of weighted shortcut edges such that in the augmented graph, all pairwise (or specified) shortest-path distances can be approximated to within a desired stretch using a path of at most a specified number of hops. Hopsets have become foundational primitives in parallel, distributed, dynamic, and streaming graph algorithms, enabling a diverse array of efficient approximate distance computations, metric compression, routing schemes, and graph sparsification.

## 1. Definition and Basic Properties

Let \( G = (V, E, w) \) be a (weighted or unweighted) graph. A \((\beta, \epsilon)\)-hopset, or more generally, an \((\alpha, \beta)\)-hopset, is a set \( H \subseteq V \times V \), where each edge \((u, v) \in H\) is assigned weight \( d_G(u, v) \), such that for every \( u, v \in V \):

\[
d_G(u, v) \leq d_{G \cup H}^{(\beta)}(u, v) \leq \alpha \cdot d_G(u, v)
\]
or, in the case of multiplicative $(1+\epsilon)$ stretch,
\[
d_G(u, v) \leq d_{G \cup H}^{(\beta)}(u, v) \leq (1+\epsilon) d_G(u, v)
\]

Here, \( d_{G \cup H}^{(\beta)}(u, v) \) is the minimum length of a $u$–$v$ path in \( G \cup H \) using at most $\beta$ edges (hops) [2009.08416, 2108.09673].

**Exact hopsets** correspond to $(\beta, 0)$ stretch, preserving all distances exactly but forcing all shortest paths to have hop-count at most $\beta$. Exact hopsets are tightly connected to the classical notion of shortcut sets for reachability and diameter reduction [2304.02193].

## 2. Classical and Modern Constructions

### Hierarchical Sampling and Thorup–Zwick–Type Constructions

The dominant paradigm constructs hopsets via random sampling and Thorup–Zwick–style clustering:

- Build a sequence $V = A_0 \supseteq A_1 \supseteq \cdots \supseteq A_L = \emptyset$ where each $A_{i+1}$ is a random sample of $A_i$.
- For each $u\in A_i \setminus A_{i+1}$, define the bunch $B(u) = \{ v \in A_i : d_G(u, v) < d_G(u, A_{i+1}) \}$.
- Add weighted shortcut edges $(u, v)$ for $v \in B(u)$, each weighted by $d_G(u, v)$ [2108.09673, 1705.00327].

This “generalized TZ” framework allows recovering all state-of-the-art tradeoffs between stretch $(\alpha)$, hopbound $(\beta)$, and size $|H|$ by appropriate choice of cluster selection and sampling parameters. For example:

| Parameters                         | Stretch ($\alpha$)           | Hopbound ($\beta$)         | Size ($|H|$)                            | Reference         |
|-------------------------------------|------------------------------|----------------------------|------------------------------------------|-------------------|
| $k$-level, multiplicative           | $2k-1$                       | 2                          | $O(kn^{1+1/k})$                          | [2108.09673]      |
| $(1+\epsilon)$-stretch, near-additive | $1+\epsilon$                | $O((\log k/\epsilon)^{\log k})$ | $O(\log k \cdot n^{1+1/k})$         | [1705.00327]      |
| Hybrid $(O(k^\epsilon), O(k^{1-\epsilon}))$ | $O(k^\epsilon)$          | $O(k^{1-\epsilon})$        | $\tilde{O}(n^{1+1/k})$                   | [2108.09673]      |

These bounds are essentially optimal; for any $(\alpha, \beta)$-hopset of size $O(n^{1+1/k})$, one must have $\alpha \cdot \beta = \Omega(k)$ [2108.09673].

### Linear-Size, Polylog-Hopbound Constructions

A major breakthrough demonstrated constructions of **linear-size hopsets** ($O(n)$ edges) with **polylogarithmic hopbound**:

- Setting $\kappa = \lceil \log n \rceil$ in the above TZ framework achieves size $O(n)$, hopbound $\beta = (\log n)^{\log^{(3)} n + O(1)}$, stretch $1+\epsilon$ [1704.08468].
- This nearly exponentially improved previous linear-hopset constructions (which required $n^{\Omega(1)}$ hopbound).

## 3. Algorithmic and Computation Models

### Parallel, Distributed, and Streaming

Hopsets are efficiently computable in a variety of algorithms models:

- **PRAM**: Hopsets of size $O(n^{1+1/\kappa})$, hopbound $O((\log \kappa / \epsilon)^{\log \kappa + O(1)})$, in polylog time and near-linear work [1704.08468].
- **Congested Clique**: Algorithms yielding $O(n^{1+1/(2k)}\log n)$-size hopsets with polylogarithmic hopbound in polylogarithmic rounds. Sparse, low-hopbound hopsets are constructed via a combination of limited neighborhood covers, clustering, and inter-cluster linking [1911.07154].
- **Dynamic/Decremental**: Near-optimal decremental hopset algorithms with polylogarithmic hopbound for weighted graphs under deletions, matching static size-hopbound tradeoffs. This enabled (2k−1)(1+ε)-approximate decremental APSP and MSSP oracles with nearly optimal bounds in both update and query time [2009.08416].
- **Streaming**: Hopsets can be constructed with $O(n^{1+1/\kappa} \log n)$ space in $O(\beta \log n)$ streaming passes [1605.04538].

### Practical Distance Oracles and Routing Schemes

Hopsets directly support the construction of low-space, low-latency routing algorithms and distance oracles:

- Compact distributed routing schemes with per-node memory $\tilde{O}(n^{1/k})$, table size $O(n^{1/k} \log n)$, stretch $O(k)$, and near-optimal construction time, via hopset-based preprocessing [1704.08468].
- Centralized distance oracles in graphs of low highway or skeleton dimension using 3-hopsets, achieving lower shortcut count than classical 2-hop hub-labeling with similar or better query times [1803.06977].

## 4. Lower Bounds and Sensitivity

### Hopbound vs. Size

The central tradeoff is: for $n$-vertex graphs, achieving hopset size $O(n^{1+1/k})$ with $(1+\epsilon)$-stretch requires $\beta = \Omega((1/\epsilon)^k)$; and for linear-size hopsets, $\beta$ cannot be improved below $(\log n)^{\log^{(3)} n - o(1)}$ [1704.08468, 1705.00327, 2211.06920]. For exact hopsets $(\epsilon = 0)$, recent lower bounds show that any $O(n)$-size hopset requires hopbound $\widetilde{\Omega}(n^{1/2})$ [2304.02193], confirming the classical folklore barrier.

### Sensitivity and Robustness

Recent work has introduced **vertex/edge sensitivity** as a quality measure for hopsets, defined as the maximum number of times a vertex (or edge) is bypassed by any hopset edge. The Greedy-Hopset achieves $(\widetilde{O}(\sqrt{n}), 0)$-hopsets with $O(\log n)$ sensitivity, improving bounds for differentially private range query algorithms, but it is shown that $\beta \cdot (\nu_\infty)^2 = \Omega(n)$ for any such construction [2407.10249]. Analogous trade-offs are matched for directed graphs and for $(\beta, \epsilon)$-hopsets.

## 5. Directed Hopsets, Shortcut Sets, and Nonlinear Tradeoffs

A shortcut set for a directed graph is a collection of edges that preserves reachability by bounding the diameter after augmentation. There is now a tight relationship between linear-size directed hopsets (approximate or reachability) and shortcut sets:

- Kogan and Parter [SODA'22] proved that $O(n)$-size shortcut sets with hopbound $\widetilde{O}(n^{1/3})$ exist; subsequently, approximate $(\beta, \epsilon)$ hopsets with $O(n)$ size and $\widetilde{O}(n^{1/3})$ hopbound were shown, closing the gap between shortcut sets and hopsets in the directed setting [2207.04507].
- The Greedy-Hopset matches existential size-optimality (up to subpolynomial factors) for exact hopsets compared to known lower bounds, and specialized deterministic algorithms can now construct $O(n)$-size, $O(n^{1/3})$-hopbound shortcut sets/directed hopsets in $O(mn^{2/3})$ time [2511.20111].

## 6. Hopsets, Spanners, Emulators, and Metric Compression

Hopsets form a bridge between spanners/emulators and distance preservers:

- Any hopset-based compression can be converted to an “$r$-missing $t$-spanner,” and further reduced to pairwise preservers and near-additive spanners, via a general black-box reduction [2211.06920].
- Thorup–Zwick’s additive emulators are also universally optimal hopsets, with $(O((k/\epsilon)^k), \epsilon)$ parameters and $O(n^{1+1/(2^{k+1}-1)})$ size, matching known lower bounds [1705.00327].
- Lower bounds on hopset parameters thus feed directly into the limitations for sparse spanners and metric emulators.

## 7. Open Problems and Research Directions

- **Closing Gaps:** Is it possible to obtain linear-size hopsets with hopbound $O(\log^{O(1)} n)$, or are the lower bounds tight? Can the $n^{1/2}$ lower bound for exact hopsets be improved or circumvented in restricted settings?
- **Directed and Hybrid Models:** Extending the full suite of hopset techniques to directed or mixed-metric graphs remains challenging [1704.08468].
- **Dynamic and Streaming Maintenance:** Efficient dynamic maintenance of small hopbound, linear-size hopsets remains largely open [2009.08416].
- **Sensitivity/Robustness:** Can the lower sensitivity guarantees be improved for hopsets with better hop/stretch parameters [2407.10249]?
- **Metric Compression:** Deepening the connection between hopset-based and spanner-based metric compression, and determining more general reverse reductions, is a proposed direction [2211.06920].

Hopsets remain a central graph-theoretic and algorithmic primitive with fundamental roles in distance approximation, parallel and distributed computation, graph compression, and modern shortest-path algorithms. The rich space of parameter tradeoffs, sensitivity criteria, and algorithmic models continues to drive theoretical advances and practical applications.

Source: https://www.emergentmind.com/topics/hop-sets