BMSSP: Bounded Multi-Source Shortest Path

• BMSSP is defined as the multi-source shortest path problem where distances from a designated source set are computed exactly or within a (1+ε) factor.
• The methodology leverages hopsets, emulators, and fast rectangular matrix multiplication to efficiently address BMSSP across centralized, PRAM, and distributed models.
• Recent research demonstrates near-optimal algorithms in models such as HYBRID and Congested Clique, effectively bridging the gap between SSSP and APSP.

Searching arXiv for BMSSP and related shortest-path papers to ground the article in the cited literature. Bounded Multi-Source Shortest Path (BMSSP) is the problem of computing distances from a designated source set $S \subseteq V$ to all vertices of a graph, typically requiring either exact distances $\mathrm{dist}(s,v)$ or estimates $\tilde d(s,v)$ satisfying $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$ for all $(s,v)\in S\times V$. The problem appears under several closely related names. In the HYBRID literature, the “Bounded Multi-Source Shortest Paths” problem on $n$ nodes with $k$ sources is exactly $k$-SSP, while in centralized and parallel settings it is often presented as MSSP or as $S\times V$ shortest paths (Schneider, 2023). Recent work places BMSSP at the intersection of hopsets, emulators, rectangular matrix multiplication, low-diameter decompositions, and communication-constrained distributed computation, yielding near-tight or optimal bounds in centralized, PRAM, Congested Clique, and HYBRID models (Elkin et al., 2020, Dory et al., 2020, Saha et al., 25 Jun 2026).

1. Problem formulation and model-dependent variants

BMSSP is defined on a graph $G=(V,E)$ with a distinguished source set $\mathrm{dist}(s,v)$0. In the weighted approximation setting, the goal is to compute $\mathrm{dist}(s,v)$1-approximate distances for all pairs in $\mathrm{dist}(s,v)$2. In the exact undirected unweighted setting, the task is to compute $\mathrm{dist}(s,v)$3 for every $\mathrm{dist}(s,v)$4 and $\mathrm{dist}(s,v)$5. The reachability analogue replaces finite distances by a Boolean distinction between finite and infinite distance. These formulations are all explicit in the recent BMSSP/MSSP literature (Elkin et al., 2020, Saha et al., 25 Jun 2026).

The source-set size is usually parameterized either as $\mathrm{dist}(s,v)$6 with $\mathrm{dist}(s,v)$7, or as $\mathrm{dist}(s,v)$8 with $\mathrm{dist}(s,v)$9, depending on the paper. In HYBRID, the same problem is written with $\tilde d(s,v)$0, and every node $\tilde d(s,v)$1 must learn $\tilde d(s,v)$2 for all $\tilde d(s,v)$3, either exactly or up to a stretch $\tilde d(s,v)$4 (Schneider, 2023).

A plausible implication is that “bounded” is not used with a single universal formal restriction across all papers. Rather, it denotes a multi-source shortest-path regime in which the number of sources is treated as a parameter of the complexity analysis, such as $\tilde d(s,v)$5, $\tilde d(s,v)$6, or $\tilde d(s,v)$7. This explains why the same underlying task is alternately discussed as BMSSP, MSSP, or $\tilde d(s,v)$8-SSP in different computational models.

2. Hopsets, emulators, and distance products as a general algorithmic template

A central line of work reduces BMSSP to repeated approximate distance products between an $\tilde d(s,v)$9 matrix and an $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$0 adjacency matrix. In the weighted undirected setting, the framework of hopsets plus rectangular fast matrix multiplication gives a $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$1-approximation for all distances from $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$2 sources. For any integer $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$3, one can build a hopset $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$4 of $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$5 edges in time $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$6, with hopbound $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$7, and then perform $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$8 relaxation rounds based on approximate distance products. With the choice $d_G(s,v)\le \tilde d(s,v)\le (1+\epsilon)d_G(s,v)$9, this yields total centralized running time

$(s,v)\in S\times V$0

where $(s,v)\in S\times V$1 is the time for multiplying an $(s,v)\in S\times V$2 matrix by an $(s,v)\in S\times V$3 matrix (Elkin et al., 2020).

The same template extends to PRAM. The hopset can be built in parallel time $(s,v)\in S\times V$4 with work $(s,v)\in S\times V$5, and each approximate distance product takes $(s,v)\in S\times V$6 parallel time with $(s,v)\in S\times V$7 work. Tuning $(s,v)\in S\times V$8 yields PRAM time $(s,v)\in S\times V$9 and work $n$0 for any arbitrarily small constant $n$1 (Elkin et al., 2020).

In the Congested Clique, the same conceptual decomposition remains useful but requires a distributed rectangular matrix-multiplication primitive. The resulting bound is

$n$2

In particular, for $n$3, the paper obtains polylogarithmic round complexity in weighted graphs, and for unweighted graphs with $n$4, it achieves $n$5 rounds with high probability (Elkin et al., 2020).

This family of results establishes BMSSP as an intermediate problem between single-source and all-pairs shortest paths. The performance varies smoothly with the source exponent $n$6, rather than forcing an immediate transition from repeated SSSP to full APSP.

3. Deterministic BMSSP in the Congested Clique

For unweighted undirected graphs and $n$7 sources, a separate deterministic line of work obtains a poly$n$8-round Congested-Clique algorithm. The target guarantee is $n$9-approximate distances $k$0 satisfying

$k$1

The algorithm separates source-target pairs into “long” distances and “short” distances around a threshold

$k$2

and handles the two regimes by different mechanisms (Dory et al., 2020).

For long distances, it constructs a sparse near-additive emulator $k$3 with $k$4 edges and $k$5-stretch. The emulator is built from a hierarchy

$k$6

with sampling probabilities $k$7 for $k$8, together with radii $k$9 and cumulative budgets $k$0. The stretch analysis proves

$k$1

which after rescaling yields the stated $k$2-emulator (Dory et al., 2020).

For short distances, the algorithm builds a bounded hopset $k$3 for radius $k$4, forms $k$5, and then runs $k$6-source detection from the source set $k$7 with hop-bound $k$8. The output is a $k$9-approximation for all source-target pairs of true distance at most $S\times V$0, and the final answer takes the minimum of the long-regime emulator estimate and the short-regime hopset estimate (Dory et al., 2020).

A notable feature is derandomization. Every random hitting-set step is replaced by a soft-hitting-set routine that can be derandomized in $S\times V$1 rounds, using a pseudorandom generator of seed $S\times V$2 bits and the method of conditional expectations. The final outcome is a deterministic $S\times V$3-round BMSSP algorithm for $S\times V$4, improving on previous deterministic poly$S\times V$5-round bounds in the Congested Clique (Dory et al., 2020).

4. Near-tight BMSSP in the HYBRID model

In the synchronous message-passing HYBRID model, nodes have two communication modes per round: local communication along graph edges with unbounded message size, $S\times V$6, and global communication between arbitrary pairs with total per-node bandwidth $S\times V$7 bits. The notation is

$S\times V$8

Within this model, BMSSP is exactly $S\times V$9-SSP: given an undirected weighted graph $G=(V,E)$0 and a set $G=(V,E)$1 of $G=(V,E)$2 sources, every node must learn its distance to all sources, either exactly or approximately (Schneider, 2023).

The main upper bound is a randomized algorithm that, with high probability, computes a $G=(V,E)$3-approximation to $G=(V,E)$4-SSP in

$G=(V,E)$5

rounds for any $G=(V,E)$6 and any constant $G=(V,E)$7. More generally, if the global bandwidth is $G=(V,E)$8 bits per node per round, the complexity becomes

$G=(V,E)$9

This matches the known lower bound up to polylogarithmic factors for the full range of $\mathrm{dist}(s,v)$00 (Schneider, 2023).

The algorithm combines several ingredients. First, it simulates the Minor-Aggregation interface in HYBRID in $\mathrm{dist}(s,v)$01 rounds and implements a PRAM-based Eulerian-Orientation oracle via network decompositions and forest-cover reductions. This yields an $\mathrm{dist}(s,v)$02-approximate SSSP routine in $\mathrm{dist}(s,v)$03 rounds. Second, it samples a skeleton set $\mathrm{dist}(s,v)$04 by selecting each node independently with probability $\mathrm{dist}(s,v)$05, where $\mathrm{dist}(s,v)$06. A weighted skeleton graph $\mathrm{dist}(s,v)$07 is then built on $\mathrm{dist}(s,v)$08, inserting $\mathrm{dist}(s,v)$09 whenever $\mathrm{dist}(s,v)$10 and giving that edge weight $\mathrm{dist}(s,v)$11. In $\mathrm{dist}(s,v)$12 rounds, the construction ensures that for all $\mathrm{dist}(s,v)$13, $\mathrm{dist}(s,v)$14, and no shortest-path segment of at least $\mathrm{dist}(s,v)$15 hops avoids the sampled skeleton (Schneider, 2023).

Third, for each skeleton node $\mathrm{dist}(s,v)$16, the algorithm computes a helper set $\mathrm{dist}(s,v)$17 of size $\mathrm{dist}(s,v)$18 within hop-radius $\mathrm{dist}(s,v)$19, such that each real node participates in $\mathrm{dist}(s,v)$20 sets. The $\mathrm{dist}(s,v)$21 SSSP instances are distributed across helpers, with each helper simulating $\mathrm{dist}(s,v)$22 instances. By the scheduling theorem in the paper, all instances on the skeleton can be completed in $\mathrm{dist}(s,v)$23 rounds. Finally, every node $\mathrm{dist}(s,v)$24 fetches approximate distances $\mathrm{dist}(s,v)$25 from skeleton nodes $\mathrm{dist}(s,v)$26 within $\mathrm{dist}(s,v)$27 hops and outputs

$\mathrm{dist}(s,v)$28

By the sampling lemma and the skeleton stretch guarantee, this gives overall stretch $\mathrm{dist}(s,v)$29 for random sources and stretch $\mathrm{dist}(s,v)$30 for adversarial sources (Schneider, 2023).

The lower bound, due to Kuhn–Schneider, shows that any HYBRID algorithm, even randomized and even for huge stretch, requires

$\mathrm{dist}(s,v)$31

rounds. The reduction encodes $\mathrm{dist}(s,v)$32-bit inputs across $\mathrm{dist}(s,v)$33 disjoint source sets whose pairwise distances differ by $\mathrm{dist}(s,v)$34 or $\mathrm{dist}(s,v)$35 hop, and yields the sketch inequality

$\mathrm{dist}(s,v)$36

which implies $\mathrm{dist}(s,v)$37 (Schneider, 2023).

These bounds close the earlier gap between upper bounds such as $\mathrm{dist}(s,v)$38 or $\mathrm{dist}(s,v)$39 and the lower bound for small $\mathrm{dist}(s,v)$40. Consequences stated explicitly include $\mathrm{dist}(s,v)$41-round APSP when $\mathrm{dist}(s,v)$42, $\mathrm{dist}(s,v)$43-round SSSP when $\mathrm{dist}(s,v)$44, exact $\mathrm{dist}(s,v)$45 solutions for $\mathrm{dist}(s,v)$46 random sources, and $\mathrm{dist}(s,v)$47-approximate solutions for $\mathrm{dist}(s,v)$48 adversarial sources in the same time bound (Schneider, 2023).

5. Exact MSSP through low-diameter small-neighborhood decomposition

A recent exact result for undirected unweighted graphs gives an almost optimal BMSSP/MSSP algorithm running in

$\mathrm{dist}(s,v)$49

time for $\mathrm{dist}(s,v)$50. This matches the Boolean-matrix-multiplication lower bound and interpolates smoothly between $\mathrm{dist}(s,v)$51 for single-source and $\mathrm{dist}(s,v)$52 for all-pairs shortest paths (Saha et al., 25 Jun 2026).

The key structural ingredient is a $\mathrm{dist}(s,v)$53-decomposition, a partition

$\mathrm{dist}(s,v)$54

such that $\mathrm{dist}(s,v)$55 and $\mathrm{dist}(s,v)$56, where $\mathrm{dist}(s,v)$57. For any $\mathrm{dist}(s,v)$58, the paper computes such a decomposition in time

$\mathrm{dist}(s,v)$59

with

$\mathrm{dist}(s,v)$60

Setting $\mathrm{dist}(s,v)$61 gives $\mathrm{dist}(s,v)$62 in time $\mathrm{dist}(s,v)$63 (Saha et al., 25 Jun 2026).

The BMSSP algorithm maintains, for each source $\mathrm{dist}(s,v)$64, a current level $\mathrm{dist}(s,v)$65, the frontier $\mathrm{dist}(s,v)$66 of vertices at exact distance $\mathrm{dist}(s,v)$67, and an active bucket of not-yet-explored frontier vertices. Each cluster $\mathrm{dist}(s,v)$68 carries a score equal to the number of sources whose active set intersects $\mathrm{dist}(s,v)$69. The algorithm repeatedly selects a cluster with

$\mathrm{dist}(s,v)$70

If $\mathrm{dist}(s,v)$71 is small, it performs direct relaxation. If $\mathrm{dist}(s,v)$72 is large, it constructs Boolean matrices

$\mathrm{dist}(s,v)$73

and uses their product $\mathrm{dist}(s,v)$74 to update many source-boundary pairs simultaneously (Saha et al., 25 Jun 2026).

The complexity analysis relies on three combinatorial facts stated in the paper: each source touches a cluster at most $\mathrm{dist}(s,v)$75 times; each cluster is selected at most $\mathrm{dist}(s,v)$76 times; and a convexity lemma collapses the total matrix-multiplication cost over all relevant iterations. After bucketing by $\mathrm{dist}(s,v)$77 and applying the rectangular matrix-multiplication exponent $\mathrm{dist}(s,v)$78, the running time becomes $\mathrm{dist}(s,v)$79 (Saha et al., 25 Jun 2026).

The paper also states several extensions. For integer weights in $\mathrm{dist}(s,v)$80, bounded-weight MSSP can be solved in $\mathrm{dist}(s,v)$81 time. Multiple-source reachability in directed graphs can be solved in $\mathrm{dist}(s,v)$82 time, and the same divide-and-conquer approach extends to MSSP on DAGs. Applications include construction of a linear-size $\mathrm{dist}(s,v)$83-hop-set of size $\mathrm{dist}(s,v)$84 in $\mathrm{dist}(s,v)$85, a $\mathrm{dist}(s,v)$86-emulator of size $\mathrm{dist}(s,v)$87 in $\mathrm{dist}(s,v)$88, and an $\mathrm{dist}(s,v)$89-time algorithm for a $\mathrm{dist}(s,v)$90-size shortcut set reducing diameter to $\mathrm{dist}(s,v)$91 (Saha et al., 25 Jun 2026).

6. Complexity landscape and conceptual significance

The recent BMSSP literature shows that the problem does not admit a single canonical complexity profile; instead, the dominant technique depends strongly on the computational model, graph class, approximation target, and source-set regime.

Setting	Regime	Stated result
Centralized / PRAM / Congested Clique	$\mathrm{dist}(s,v)$92, weighted undirected	$\mathrm{dist}(s,v)$93-approximate BMSSP via hopsets and rectangular matrix multiplication (Elkin et al., 2020)
Congested Clique	$\mathrm{dist}(s,v)$94, unweighted undirected	Deterministic poly$\mathrm{dist}(s,v)$95-round $\mathrm{dist}(s,v)$96-approximate BMSSP (Dory et al., 2020)
HYBRID	$\mathrm{dist}(s,v)$97, weighted undirected	$\mathrm{dist}(s,v)$98-round $\mathrm{dist}(s,v)$99-SSP, near-tight up to polylogarithmic factors (Schneider, 2023)
Centralized exact	$\tilde d(s,v)$00, undirected unweighted	$\tilde d(s,v)$01-time MSSP matching the BMM lower bound (Saha et al., 25 Jun 2026)

One recurring misconception is that BMSSP is merely repeated SSSP with bookkeeping. The current results show a more intricate picture. In centralized exact computation, the trivial bounds are to run BFS/SSSP from each of the $\tilde d(s,v)$02 sources in $\tilde d(s,v)$03 time or run APSP in $\tilde d(s,v)$04 time, but the 2026 algorithm instead matches the rectangular-BMM lower bound $\tilde d(s,v)$05 (Saha et al., 25 Jun 2026). In distributed settings, communication structure rather than algebraic complexity becomes decisive: the HYBRID lower bound is governed by the joint effect of global bandwidth and local congestion, while Congested Clique algorithms exploit global all-to-all communication through emulators, hopsets, and distributed matrix multiplication (Schneider, 2023, Elkin et al., 2020).

A second important distinction is between exactness and approximation. The centralized 2026 result is exact for undirected unweighted graphs, whereas the 2020 Congested-Clique and weighted centralized/PRAM results are $\tilde d(s,v)$06-approximate, and the HYBRID result gives $\tilde d(s,v)$07-approximation in general, together with exact $\tilde d(s,v)$08 behavior for random sources and $\tilde d(s,v)$09-approximation for adversarial sources in the stated consequence for BMSSP (Saha et al., 25 Jun 2026, Dory et al., 2020, Elkin et al., 2020, Schneider, 2023).

Taken together, these developments identify BMSSP as a boundary problem linking shortest paths, emulators, hopsets, matrix multiplication, and distributed lower bounds. The modern view is not merely that BMSSP generalizes SSSP, but that it exposes intermediate regimes in which neither repeated single-source computation nor full APSP is the right abstraction.