Faster Parallel Batch-Dynamic Algorithms for Low Out-Degree Orientation

A low out-degree orientation directs each edge of an undirected graph with the goal of minimizing the maximum out-degree of a vertex. In the parallel batch-dynamic setting, one can insert or delete batches of edges, and the goal is to process the entire batch in parallel with work per edge similar to that of a single sequential update and with span (or depth) for the entire batch that is polylogarithmic. In this paper we present faster parallel batch-dynamic algorithms for maintaining a low out-degree orientation of an undirected graph. All results herein achieve polylogarithmic depth, with high probability (whp); the focus of this paper is on minimizing the work, which varies across results. Our first result is the first parallel batch-dynamic algorithm to maintain an asymptotically optimal orientation with asymptotically optimal expected work bounds, in an amortized sense, improving over the prior best work bounds of Liu et al.[SPAA‘22] by a logarithmic factor. Our second result is a $O(c \log n)$ orientation algorithm with expected worst-case $O(\sqrt{\log n})$ work per edge update, where $c$ is a known upper-bound on the arboricity of the graph. This matches the best-known sequential worst-case $O(c \log n)$ orientation algorithm given by Berglin and Brodal [Algorithmica‘18], albeit in expectation. Our final result is a $O(c + \log n)$-orientation algorithm with $O(\log^2 n)$ expected worst-case work per edge update. This algorithm significantly improves upon the recent result of Ghaffari and Koo~[SPAA~‘25], which maintains a $O(c)$-orientation with $O(\log^9 n)$ worst-case work per edge whp.

💡 Research Summary

The paper studies the problem of maintaining a low out‑degree orientation of an undirected graph in the parallel batch‑dynamic model, where updates arrive in batches of edge insertions and deletions and the algorithm must process an entire batch in parallel. The goal is to keep the work per edge close to that of the best sequential algorithm while guaranteeing polylogarithmic span (depth) for the whole batch with high probability.

Three main contributions are presented:

1. An amortized optimal algorithm – This algorithm is a parallel analogue of the classic Brodal‑Fagerberg scheme. When a vertex exceeds a fixed out‑degree threshold, all its outgoing edges are collected and a static low‑out‑degree orientation is computed on the induced subgraph using a parallel semisort. This single static orientation step replaces the sequential chain of flips, preserving the same potential‑function decrease and thus the same competitive ratio (O(1) with respect to any offline orientation). For a batch of size b, insertions require O(b) expected work and O(log² n) span, deletions O(b log n) work and O(log n) span. Using randomized semisort yields the stated expected bounds; a deterministic merge‑sort variant incurs an extra O(log n) factor in work.

2. TwoStage worst‑case algorithm – Building on the k‑Flips framework of Berglin and Brodal, the algorithm repeats a flip‑step k = Θ(√log n) times per update. Edges to flip are taken from a queue that stores outgoing edges of the current maximum‑out‑degree vertex, preventing immediate back‑and‑forth flips. This yields an O(c log n) orientation while the expected worst‑case work per edge update is O(√log n). The total work for a batch of size b is O(b √log n) and the depth remains polylogarithmic.

3. Reinsertion worst‑case algorithm – This method targets an O(c + log n) orientation. On insertion, the new edge is oriented arbitrarily; if a vertex becomes “high”, all its outgoing edges are re‑inserted (re‑oriented) using the same parallel static orientation subroutine. Deletions are handled by simple removal. The expected worst‑case work per edge update is O(log² n), giving O(b log² n) work for a batch and O(log² n) span. This dramatically improves over the recent Ghaffari‑Koo result, which required O(log⁹ n) work per edge.

All three algorithms achieve polylogarithmic depth with high probability. The paper’s technical core consists of (i) a potential‑function analysis that shows each flip (or static re‑orientation) reduces a global potential by a constant amount, guaranteeing optimal total flips; (ii) a “counter game” that bounds the accumulation of potential on any single vertex, enabling worst‑case guarantees; and (iii) the use of parallel semisort to implement the static orientation step efficiently.

The authors also discuss how these orientation algorithms can be used as primitives for dynamic maximal matching, coloring, and independent‑set algorithms, yielding improved bounds for those problems as well. They note that in many real‑world graphs arboricity c is at least Ω(log n), so the additive log n term in the Reinsertion algorithm’s degree bound is negligible in practice.

In summary, the paper delivers the first work‑efficient amortized parallel batch‑dynamic algorithm for low out‑degree orientation and two substantially faster worst‑case parallel batch‑dynamic algorithms, closing the gap between sequential and parallel dynamic graph orientation and providing a foundation for faster dynamic graph algorithms in parallel settings.