DAG Projections: Reducing Distance and Flow Problems to DAGs

Abstract: We show that every directed graph $G$ with $n$ vertices and $m$ edges admits a directed acyclic graph (DAG) with $m^{1+o(1)}$ edges, called a DAG projection, that can either $(1+1/\text{polylog} (n))$-approximate distances between all pairs of vertices $(s,t)$ in $G$, or $n^{o(1)}$-approximate maximum flow between all pairs of vertex subsets $(S,T)$ in $G$. Previous similar results suffer a $Ω(\log n)$ approximation factor for distances [Assadi, Hoppenworth, Wein, STOC'25] [Filtser, SODA'26] and, for maximum flow, no prior result of this type is known. Our DAG projections admit $m^{1+o(1)}$-time constructions. Further, they admit almost-optimal parallel constructions, i.e., algorithms with $m^{1+o(1)}$ work and $m^{o(1)}$ depth, assuming the ones for approximate shortest path or maximum flow on DAGs, even when the input $G$ is not a DAG. DAG projections immediately transfer results on DAGs, usually simpler and more efficient, to directed graphs. As examples, we improve the state-of-the-art of $(1+ε)$-approximate distance preservers [Hoppenworth, Xu, Xu, SODA'25] and single-source minimum cut [Cheung, Lau, Leung, SICOMP'13], and obtain simpler construction of $(n^{1/3},ε)$-hop-set [Kogan, Parter, SODA'22] [Bernstein, Wein, SODA'23] and combinatorial max flow algorithms [Bernstein, Blikstad, Saranurak, Tu, FOCS'24] [Bernstein, Blikstad, Li, Saranurak, Tu, FOCS'25]. Finally, via DAG projections, we reduce major open problems on almost-optimal parallel algorithms for exact single-source shortest paths (SSSP) and maximum flow to easier settings: (1) From exact directed SSSP to exact undirected ones, (2) From exact directed SSSP to $(1+1/\text{polylog}(n))$-approximation on DAGs, and (3) From exact directed maximum flow to $n^{o(1)}$-approximation on DAGs.

• The paper introduces DAG projections that transform general directed graphs into nearly-linear size DAGs ensuring (1+1/polylog(n))-approximate distances and n^(o(1))-approximate max flows.
• It develops randomized, recursive algorithms using low-diameter decompositions and expander hierarchies to achieve tight approximation guarantees with m^(1+o(1)) edges.
• These techniques enable the transfer of combinatorial and parallel algorithm advances from DAGs to general digraphs, simplifying longstanding open problems in parallel complexity.

DAG Projections: A Comprehensive Reduction Framework for Distance and Flow Problems

Introduction

This paper introduces DAG projections, a structural tool that transforms distance and flow computation problems on general directed graphs into nearly equivalent problems on Directed Acyclic Graphs (DAGs). The central contribution is the development of randomized algorithms to construct DAG projections with almost-linear size ($m^{1+o(1)}$ edges) that guarantee $(1+1/\mathrm{polylog}(n))$-approximation for all-pairs shortest-path distances and $n^{o(1)}$-approximation for all-pairs maximum flows. These constructions match lower bounds on data structure size and surpass all prior directed analogs for efficient approximation (which were limited to $\Omega(\log n)$ distance approximation, and no results for all-pairs max flow).

The ramifications are broad: many algorithmic advances valid for DAGs, where combinatorial and parallel techniques are often simpler and more powerful, become transferable to general digraphs with only polylogarithmic or subpolynomial loss. This produces not only new or simpler constructions for classical objects (hop-sets, distance preservers, combinatorial max-flow algorithms) but also informs the parallel complexity landscape for shortest path and flow problems.

Structural Results: Distance and Flow DAG Projections

Distance Approximation

The paper achieves the construction of a DAG $G'$ (the DAG projection) with $m^{1+o(1)}$ edges and vertex width $n^{o(1)}$, equipped with a projection $\pi: V(G') \to V(G)$ such that for any vertices $s,t$,

$$\operatorname{dist}_G(s, t) \leq \operatorname{dist}_{G'}(\pi^{-1}(s), \pi^{-1}(t)) \leq (1+\epsilon)\operatorname{dist}_G(s, t)$$

for any $(1+1/\mathrm{polylog}(n))$0. Prior work using stochastic DAG/tree covers had approximation factors at least $(1+1/\mathrm{polylog}(n))$1 [Filtser SODA'26, Assadi et al. STOC'25], making this nearly tight.

The construction recursively exploits low-diameter decompositions (LDDs) across geometrically increasing scales, handling large strongly connected clusters through SPT-based DAG gadgets and small clusters by recursion. Replication mechanisms and "spiral recursions" allow for bootstrapping from approximate SSSP oracles on DAGs, closing the circular dependency between requiring DAG-based algorithms and constructing the reductions themselves. The final size bound follows from careful control of cluster expansion and vertex copying.

Flow Approximation

For all-pairs max-flow, the authors introduce the first congestion-preserving DAG projections: a DAG $(1+1/\mathrm{polylog}(n))$2 and projection $(1+1/\mathrm{polylog}(n))$3 such that for any vertex sets $(1+1/\mathrm{polylog}(n))$4,

$(1+1/\mathrm{polylog}(n))$5

again with DAG size $(1+1/\mathrm{polylog}(n))$6.

This is achieved by a recursive expander-decomposition hierarchy: at each stage, clusters are managed with expander routing and demand-respecting gadgets, separating the tough problem of congestion handling in general digraphs into "easy" local pieces and "hard" inter-cluster flows, which are in turn handled recursively. To break the circularity, the reduction tolerates additive errors, which are made negligible through scaling. All algorithms run in $(1+1/\mathrm{polylog}(n))$7 time, and are parallelizable to almost-optimal work and subpolynomial depth, modulo the existence of efficient DAG-based SSSP or max-flow solvers.

Applications

Parallel Algorithms and Complexity Regimes

The most significant theoretical implication is the partitioning of the parallel SSSP and max-flow regimes into two classes:

• The "easy" class consists of undirected approximation, for which nearly optimal parallel algorithms are known.
• The "hard" class includes exact or nearly exact SSSP and all-pairs max-flow on directed graphs, DAGs, or undirected graphs—these are now shown to be equivalent up to $(1+1/\mathrm{polylog}(n))$8 factors via the new reductions.

Therefore, advances in parallel computation for any "hard" instance (e.g., for DAGs) propagate to all, and future progress can focus on the (ostensibly) simpler DAG or undirected settings.

Algorithmic Improvements

• Distance Preservers: By reducing the problem to the DAG regime, the size of $(1+1/\mathrm{polylog}(n))$9-approximate distance preservers in general digraphs achieves $n^{o(1)}$0, closing longstanding gaps with the DAG and undirected cases for $n^{o(1)}$1 demands.
• Hop-sets: The recursive construction streamlines the previously convoluted process of constructing hop-sets with sublinear hops for general digraphs, matching the $n^{o(1)}$2 hop bound that was previously obtainable only in DAGs.
• Combinatorial Max-Flow: Recent advances in combinatorial algorithms for DAG max-flow [Bernstein et al.] can now be lifted to general digraphs with only $n^{o(1)}$3 overhead, enabling efficient approximate flow routines without recourse to heavy polylogarithmic hierarchies.

Further Implications

Large classes of min-distance and min-cut problems where DAGs admit algorithmic improvements over general digraphs are now approachable through these projections. Additionally, open problems such as vertex cut sparsifiers for $n^{o(1)}$4-terminals on general digraphs (with approximations) may yield to this framework.

Methodological Elements

• Homomorphic Projections and Vertex Width: The construction enforces strict homomorphism (edges only connect copies respecting the original adjacency), avoiding artifacts of stochastic embeddings, which is essential for certain reduction properties.
• LDDs and Expander Hierarchies: The use of hierarchical decompositions allows for the isolation of "hard" parts of the graph recursively, and the manipulation of flows and distances in a controlled fashion, reducing approximation loss accumulation.
• Spiral Recursion and Self-Reduction: The algorithms cleverly reduce their own construction to easier DAG-based subproblems, via sequence and "induced" graph gadgets, such that progress is guaranteed on the length or slack parameter at each recursion.

Conclusion

The paper systematically establishes that up to subpolynomial loss, shortest-path and max-flow problems for all general directed graphs can be effectively reduced in bulk to analogous problems on DAGs of nearly linear size. This pushes the state-of-the-art in fine-grained reductions for graph algorithms, collapses substantial open directions in parallel complexity, and directly advances the practical and theoretical toolkit for combinatorial and parallel algorithm design. The tools and reductions provided supply a common lens to reinterpret previous progress and guide effort towards the truly essential difficulties in distance and flow computation on directed graphs.

Reference: "DAG Projections: Reducing Distance and Flow Problems to DAGs" (2604.04752)