Arrow Research search

Author name cluster

Aaron Bernstein

Possible papers associated with this exact author name in Arrow. This page groups case-insensitive exact name matches and is not a full identity disambiguation profile.

28 papers
1 author row

Possible papers

28

FOCS Conference 2025 Conference Paper

Combinatorial Maximum Flow via Weighted Push-Relabel on Shortcut Graphs

  • Aaron Bernstein
  • Joakim Blikstad
  • Jason Li 0006
  • Thatchaphol Saranurak
  • Ta-Wei Tu

We give a combinatorial algorithm for computing exact maximum flows in directed graphs with n vertices and edge capacities from {1, …, U} in $\tilde O\left({{n^2}\log U}\right)$ time, which is near-optimal on dense graphs. This shaves an n o(1) factor from the recent result of [Bernstein–Blikstad–Saranurak–Tu FOCS’24] and, more importantly, greatly simplifies their algorithm. We believe that ours is by a significant margin the simplest of all algorithms that go beyond $\tilde O(m\sqrt n )$ time in general graphs. To highlight this relative simplicity, we provide a full implementation of the algorithm in C++. The only randomized component of our work is the cut-matching game. Via existing tools, we show how to derandomize it for vertex-capacitated max flow and obtain a deterministic $\tilde O\left({{n^2}}\right)$ time algorithm. This marks the first deterministic near-linear time algorithm for this problem (or even for the special case of bipartite matching) in any density regime.

STOC Conference 2025 Conference Paper

Deterministic Dynamic Maximal Matching in Sublinear Update Time

  • Aaron Bernstein
  • Sayan Bhattacharya
  • Peter Kiss
  • Thatchaphol Saranurak

We give a fully dynamic deterministic algorithm for maintaining a maximal matching of an n -vertex graph in Õ( n 8/9 ) amortized update time. This breaks the long-standing Ω( n )-update-time barrier on dense graphs, achievable by trivially scanning all incident vertices of the updated edge, and affirmatively answers a major open question repeatedly asked in the literature Baswana, Gupta and Sen [FOCS 2011], Bhattacharya,Chakrabarty, Henzinger and Nanongkai [SODA 2018], Solomon [Dagstuhl]. We also present a faster randomized algorithm against an adaptive adversary with Õ( n 3/4 ) amortized update time. Our approach employs the edge degree constrained subgraph (EDCS), a central object for optimizing approximation ratio, in a completely novel way; we instead use it for maintaining a matching that matches all high degree vertices in sublinear update time so that it remains to handle low degree vertices rather straightforwardly. To optimize this approach, we employ tools never used in the dynamic matching literature prior to our work, including sublinear-time algorithms for matching high degree vertices, random walks on directed expanders, and the monotone Even-Shiloach tree for dynamic shortest paths.

FOCS Conference 2024 Conference Paper

Maximum Flow by Augmenting Paths in n 2+o(1) Time

  • Aaron Bernstein
  • Joakim Blikstad
  • Thatchaphol Saranurak
  • Ta-Wei Tu

We present a combinatorial algorithm for computing exact maximum flows in directed graphs with $n$ vertices and edge capacities from $\{1, \ldots, U\}$ in $n^{2+o(1)}\log U$ time, which is almost optimal in dense graphs. Our algorithm is a novel implementation of the classical augmenting-path framework; we list augmenting paths more efficiently using a new variant of the push-relabel algorithm that uses additional edge weights to guide the algorithm, and we derive the edge weights by constructing a directed expander hierarchy. Even in unit-capacity graphs, this breaks the long-standing $O(m \cdot\min\{\sqrt{m}, n^{2/3}\})$ time bound of the previous combinatorial algorithms by Karzanov (1973) and Even and Tarjan (1975) when the graph has $m=\omega(n^{4/3})$ edges. Notably, our approach does not rely on continuous optimization nor heavy dynamic graph data structures, both of which are crucial in the recent developments that led to the almost-linear time algorithm by Chen et al. (FOCS 2022). Our running time also matches the $n^{2+o(1)}$ time bound of the independent combinatorial algorithm by Chuzhoy and Khanna (STOC 2024) for computing the maximum bipartite matching, a special case of maximum flow.

SODA Conference 2023 Conference Paper

Closing the Gap Between Directed Hopsets and Shortcut Sets

  • Aaron Bernstein
  • Nicole Wein

For an n-vertex directed graph G = ( V, E ), a β-shortcut set H is a set of additional edges H ⊆ V × V such that G U H has the same transitive closure as G, and for every pair u, v ∈ V, there is a uv-path in G U H with at most β edges. A natural generalization of shortcut sets to distances is a ( β, ε )-hopset H ⊆ V × V, where the requirement is that H and G U H have the same shortest-path distances, and for every u, v ε V, there is a (1 + ε )-approximate shortest path in G U H with at most β edges. There is a large literature on the question of the tradeoff between the optimal size of a shortcut set / hopset and the value of β. In particular we highlight the most natural point on this tradeoff: what is the minimum value of β, such that for any graph G, there exists a β-shortcut set H with O(n) edges? Similarly, what is the minimum value of β such that there exists a ( β, ε )-hopset with O ( n ) edges? Not only is this a very natural structural question in its own right, but shortcuts sets / hopsets form the core of a large number of distributed, parallel, and dynamic algorithms for reachability / shortest paths. A lower bound of Hesse [SODA 2003] for directed graphs shows that if we restrict ourselves to hopsets with O ( n ) edges, the best we can guarantee is β = Ω( n 1/17 ) for both shortcut sets and hopsets [SODA 2003]; this was later improved to β = Ω( n 1/6 ) by Huang and Pettie [SWAT 2018]. Until very recently the best known upper bound was a folklore construction showing β = O ( n 1/2 ), but in a breakthrough result Kogan and Parter [SODA 2022] improve this to β = Õ ( n 1/3 ) for shortcut sets and Õ ( n 2/5 ) for hopsets. Our result in this paper is to close the gap between shortcut sets and hopsets introduced by the result of Kogan and Parter. That is, we show that for any graph G and any fixed ε there is a ( Õ ( n 1/3 ), ε ) hopset with O ( n ) edges. Our hopset improves upon the ( Õ (n 2/5 ), ε ) hopset of Kogan and Parter. More generally, we achieve a smooth tradeoff between hopset size and β which exactly matches the tradeoff of Kogan and Parter for the simpler problem of shortcut sets (up to polylog factors). Additionally, using a very recent black-box reduction of Kogan and Parter, our new hopset immediately implies improved bounds for approximate distance preservers.

FOCS Conference 2022 Conference Paper

Negative-Weight Single-Source Shortest Paths in Near-linear Time

  • Aaron Bernstein
  • Danupon Nanongkai
  • Christian Wulff-Nilsen

We present a randomized algorithm that computes single-source shortest paths (SSSP) in $O\left(m \log ^{8}(n) \log W\right)$ time when edge weights are integral and can be negative. 1 This essentially resolves the classic negative-weight SSSP problem. The previous bounds are $\tilde{O}\left(\left(m+n^{1. 5}\right) \log W\right)$ [BLNPSSSW FOCS’20] and $m^{4 / 3+o(1)} \log W$ [AMV FOCS’20]. Near-linear time algorithms were known previously only for the special case of planar directed graphs [Fakcharoenphol and Rao FOCS’01]. In contrast to all recent developments that rely on sophisticated continuous optimization methods and dynamic algorithms, our algorithm is simple: it requires only a simple graph decomposition and elementary combinatorial tools. In fact, ours is the first combinatorial algorithm for negative-weight SSSP to break through the classic $O(m \sqrt{n} \log W)$ bound from over three decades ago [Gabow and Tarjan SICOMP’89].

STOC Conference 2021 Conference Paper

A framework for dynamic matching in weighted graphs

  • Aaron Bernstein
  • Aditi Dudeja
  • Zachary Langley

We introduce a new framework for computing approximate maximum weight matchings. Our primary focus is on the fully dynamic setting, where there is a large gap between the guarantees of the best known algorithms for computing weighted and unweighted matchings. Indeed, almost all current weighted matching algorithms that reduce to the unweighted problem lose a factor of two in the approximation ratio. In contrast, in other sublinear models such as the distributed and streaming models, recent work has largely closed this weighted/unweighted gap. For bipartite graphs, we almost completely settle the gap with a general reduction that converts any algorithm for α-approximate unweighted matching to an algorithm for (1−)α-approximate weighted matching, while only increasing the update time by an O (log n ) factor for constant . We also show that our framework leads to significant improvements for non-bipartite graphs, though not in the form of a universal reduction. In particular, we give two algorithms for weighted non-bipartite matching: 1. A randomized (Las Vegas) fully dynamic algorithm that maintains a (1/2−)-approximate maximum weight matching in worst-case update time O (polylog n ) with high probability against an adaptive adversary. Our bounds are essentially the same as those of the unweighted algorithm of Wajc [STOC 2020]. 2. A deterministic fully dynamic algorithm that maintains a (2/3−)-approximate maximum weight matching in amortized update time O ( m 1/4 ). Our bounds are essentially the same as those of the unweighted algorithm of Bernstein and Stein [SODA 2016]. A key feature of our framework is that it uses existing algorithms for unweighted matching as black-boxes. As a result, our framework is simple and versatile. Moreover, our framework easily translates to other models, and we use it to derive new results for the weighted matching problem in streaming and communication complexity models.

FOCS Conference 2021 Conference Paper

Deterministic Decremental SSSP and Approximate Min-Cost Flow in Almost-Linear Time

  • Aaron Bernstein
  • Maximilian Probst Gutenberg
  • Thatchaphol Saranurak

In the decremental single-source shortest paths problem, the goal is to maintain distances from a fixed source $s$ to every vertex $v$ in an m-edge graph undergoing edge deletions. In this paper, we conclude a long line of research on this problem by showing a near-optimal deterministic data structure that maintains (1 + E) -approximate distance estimates and runs in m 1+o(1) total update time. Our result, in particular, removes the oblivious adversary assumption required by the previous breakthrough result by Henzinger et al. [FOCS'14], which leads to our second result: the first almost-linear time algorithm for (1 - E) -approximate min-cost flow in undirected graphs where capacities and costs can be taken over edges and vertices. Previously, algorithms for max flow with vertex capacities, or min-cost flow with any capacities required super-linear time. Our result essentially completes the picture for approximate flow in undirected graphs. The key technique of the first result is a novel framework that allows us to treat low-diameter graphs like expanders. This allows us to harness expander properties while bypassing shortcomings of expander decomposition, which almost all previous expander-based algorithms needed to deal with. For the second result, we break the notorious flow-decomposition barrier from the multiplicative-weight-update framework using randomization.

FOCS Conference 2020 Conference Paper

Deterministic Decremental Reachability, SCC, and Shortest Paths via Directed Expanders and Congestion Balancing

  • Aaron Bernstein
  • Maximilian Probst Gutenberg
  • Thatchaphol Saranurak

Let G=(V, E, w) be a weighted, directed graph subject to a sequence of adversarial edge deletions. In the decremental single-source reachability problem (SSR), we are given a fixed source s and the goal is to maintain a data structure that can answer path-queries s\rightarrowtail v for any v ∈ V. In the more general single-source shortest paths (SSSP) problem the goal is to return an approximate shortest path to v, and in the SCC problem the goal is to maintain strongly connected components of G and to answer path queries within each component. All of these problems have been very actively studied over the past two decades, but all the fast algorithms are randomized and, more significantly, they can only answer path queries if they assume a weaker model: they assume an oblivious adversary which is not adaptive and must fix the update sequence in advance. This assumption significantly limits the use of these data structures, most notably preventing them from being used as subroutines in static algorithms. All the above problems are notoriously difficult in the adaptive setting. In fact, the state-of-the-art is still the Even and Shiloach tree, which dates back all the way to 1981 [1] and achieves total update time O(mn). We present the first algorithms to break through this barrier. i) deterministic decremental SSR/SSC with total update time mn 2/3+o(1) ii) deterministic decremental SSSP with total update time n 2+2/3+o(1) To achieve these results, we develop two general techniques for working with dynamic graphs. The first generalizes expander-based tools to dynamic directed graphs. While these tools have already proven very successful in undirected graphs, the underlying expander decomposition they rely on does not exist in directed graphs. We thus need to develop an efficient framework for using expanders in directed graphs, as well as overcome several technical challenges in processing directed expanders. We establish several powerful primitives that we hope will pave the way for other expander-based algorithms in directed graphs. The second technique, which we call congestion balancing, provides a new method for maintaining flow under adversarial deletions. The results above use this technique to maintain an embedding of an expander. The technique is quite general, and to highlight its power, we use it to achieve the following additional result: iii) The first near-optimal algorithm for decremental bipartite matching.

FOCS Conference 2020 Conference Paper

Near-Optimal Decremental SSSP in Dense Weighted Digraphs

  • Aaron Bernstein
  • Maximilian Probst Gutenberg
  • Christian Wulff-Nilsen

In the decremental Single-Source Shortest Path problem (SSSP), we are given a weighted directed graph G = (V, E, w) undergoing edge deletions and a source vertex r ∈ V; let n=|V|, m=|E| and W be the aspect ratio of the graph. The goal is to obtain a data structure that maintains shortest paths from r to all vertices in V and can answer distance queries in O(1) time, as well as return the corresponding path P in O(|P|) time. This problem was first considered by Even and Shiloach [JACM'81], who provided an algorithm with total update time O(mn) for unweighted undirected graphs; this was later extended to directed weighted graphs [FOCS'95, STOC'99]. There are conditional lower bounds showing that O(mn) is in fact near-optimal [ESA'04, FOCS'14, STOC'15, STOC'20]. In a breakthrough result, Forster et al. showed that total update time min{m 7/6 n 2/3+o(1), m 3/4 n 5/4+o(1) } polylog(W) = mn 0. 9+o(1) polylog (W), is possible if the algorithm is allowed to return ( 1 +ε)-approximate paths, instead of exact ones [STOC'14, ICALP'15]. No further progress was made until Probst Gutenberg and Wulff-Nilsen [SODA'20] provided a new approach for the problem, which yields total time ~O(min{m 2/3 n 4/3 logW, (mn) 7/8 logW}) = ~O(min{n 8/3 logW, mn 3/4 logW}). Our result builds on this recent approach, but overcomes its limitations by introducing a significantly more powerful abstraction, as well as a different core subroutine. Our new framework yields a decremental ( 1+ε)-approximate SSSP data structure with total update time ~O(n 2 log 4 W/ε). Our algorithm is thus near-optimal for dense graphs with polynomial edge-weights. Our framework can also be applied to sparse graphs to obtain total update time ~O(mn 2/3 log 3 W/ε). Combined, these data structures dominate all previous results. Like all previous o(mn) algorithms that can return a path (not just a distance estimate), our result is randomized and assumes an oblivious adversary. Our framework effectively allows us to reduce SSSP in general graphs to the same problem in directed acyclic graphs (DAGs). We believe that our framework has significant potential to influence future work on directed SSSP, both in the dynamic model and in others.

SODA Conference 2019 Conference Paper

Coresets Meet EDCS: Algorithms for Matching and Vertex Cover on Massive Graphs

  • Sepehr Assadi
  • MohammadHossein Bateni
  • Aaron Bernstein
  • Vahab Mirrokni
  • Cliff Stein 0001

There is a rapidly growing need for scalable algorithms that solve classical graph problems, such as maximum matching and minimum vertex cover, on massive graphs. For massive inputs, several different computational models have been introduced, including the streaming model, the distributed communication model, and the massively parallel computation (MPC) model that is a common abstraction of MapReduce-style computation. In each model, algorithms are analyzed in terms of resources such as space used or rounds of communication needed, in addition to the more traditional approximation ratio. In this paper, we give a single unified approach that yields better approximation algorithms for matching and vertex cover in all these models. The highlights include: The first one pass, significantly-better-than-2-approximation for matching in random arrival streams that uses subquadratic space, namely a (1. 5 + ε )-approximation streaming algorithm that uses Õ ( n 15 ) space for constant ε > 0. The first 2-round, better-than-2-approximation for matching in the MPC model that uses subquadratic space per machine, namely a (1. 5 + ε )-approximation algorithm with memory per machine for constant ε > 0. By building on our unified approach, we further develop parallel algorithms in the MPC model that give a (1+ ∊ )-approximation to matching and an O (1)-approximation to vertex cover in only O (log log n ) MPC rounds and O ( n /polylog( n )) memory per machine. These results settle multiple open questions posed by Czumaj et al. [STOC 2018]. We obtain our results by a novel combination of two previously disjoint set of techniques, namely randomized composable coresets and edge degree constrained subgraphs (EDCS). We significantly extend the power of these techniques and prove several new structural results. For example, we show that an EDCS is a sparse certificate for large matchings and small vertex covers that is quite robust to sampling and composition.

STOC Conference 2019 Conference Paper

Decremental strongly-connected components and single-source reachability in near-linear time

  • Aaron Bernstein
  • Maximilian Probst Gutenberg
  • Christian Wulff-Nilsen

Computing the Strongly-Connected Components (SCCs) in a graph G =( V , E ) is known to take only O ( m + n ) time using an algorithm by Tarjan from 1972[SICOMP 72] where m = | E |, n =| V |. For fully-dynamic graphs, conditional lower bounds provide evidence that the update time cannot be improved by polynomial factors over recomputing the SCCs from scratch after every update. Nevertheless, substantial progress has been made to find algorithms with fast update time for decremental graphs, i.e. graphs that undergo edge deletions. In this paper, we present the first algorithm for general decremental graphs that maintains the SCCs in total update time Õ( m ), thus only a polylogarithmic factor from the optimal running time. Previously such a result was only known for the special case of planar graphs [Italiano et al, STOC 17]. Our result should be compared to the formerly best algorithm for general graphs achieving Õ( m √ n ) total update time by Chechik et.al. [FOCS 16] which improved upon a breakthrough result leading to O ( mn 0.9 + o (1) ) total update time by Henzinger, Krinninger and Nanongkai [STOC 14, ICALP 15]; these results in turn improved upon the longstanding bound of O ( mn ) by Roditty and Zwick [STOC 04]. All of the above results also apply to the decremental Single-Source Reachability (SSR) problem, which can be reduced to decrementally maintaining SCCs. A bound of O ( mn ) total update time for decremental SSR was established already in 1981 by Even and Shiloach [JACM 81].

STOC Conference 2019 Conference Paper

Distributed exact weighted all-pairs shortest paths in near-linear time

  • Aaron Bernstein
  • Danupon Nanongkai

In the distributed all-pairs shortest paths problem (APSP), every node in the weighted undirected distributed network (the CONGEST model) needs to know the distance from every other node using least number of communication rounds (typically called time complexity ). The problem admits (1+ o (1))-approximation Θ( n )-time algorithm and a nearly-tight Ω( n ) lower bound [Nanongkai, STOC’14; Lenzen and Patt-Shamir PODC’15]. For the exact case, Elkin [STOC’17] presented an O ( n 5/3 log 2/3 n ) time bound, which was later improved to Õ( n 5/4 ) in [Huang, Nanongkai, Saranurak FOCS’17].It was shown that any super-linear lower bound (in n ) requires a new technique [Censor-Hillel, Khoury, Paz, DISC’17], but otherwise it remained widely open whether there exists a Õ( n )-time algorithm for the exact case, which would match the best possible approximation algorithm. This paper resolves this question positively: we present a randomized (Las Vegas) Õ( n )-time algorithm, matching the lower bound up to polylogarithmic factors. Like the previous Õ( n 5/4 ) bound, our result works for directed graphs with zero (and even negative) edge weights. In addition to the improved running time, our algorithm works in a more general setting than that required by the previous Õ( n 5/4 ) bound; in our setting (i) the communication is only along edge directions (as opposed to bidirectional), and (ii) edge weights are arbitrary (as opposed to integers in {1, 2, ... poly ( n )}). The previously best algorithm for this more difficult setting required Õ( n 3/2 ) time [Agarwal and Ramachandran, ArXiv’18] (this can be improved to Õ( n 4/3 ) if one allows bidirectional communication).

SODA Conference 2018 Conference Paper

Incremental Topological Sort and Cycle Detection in Expected Total Time

  • Aaron Bernstein
  • Shiri Chechik

In the incremental cycle detection problem edges are inserted to a directed graph (initially empty) and the algorithm has to report once a directed cycle is formed in the graph. A closely related problem to the incremental cycle detection is that of the incremental topological sort problem, in which edges are inserted to an acyclic graph and the algorithm has to maintain a valid topological sort on the vertices at all times. Both incremental cycle detection and incremental topological sort have a long history. The state of the art is a recent breakthrough of Bender, Fineman, Gilbert and Tarjan [TALG 2016], with two different algorithms with respective total update times of Õ ( n 2 ) and O ( m · min{ m 1/2, n 2/3 }). The two algorithms work for both incremental cycle detection and incremental topological sort. In this paper we introduce a novel technique that allows us to improve upon the state of the art for a wide range of graph sparsity. Our algorithms has a total expected update time of for both the incremental cycle detection and the topological sort problems.

SODA Conference 2018 Conference Paper

Online Bipartite Matching with Amortized Replacements

  • Aaron Bernstein
  • Jacob Holm
  • Eva Rotenberg

In the online bipartite matching problem with replacements, all the vertices on one side of the bipartition are given, and the vertices on the other side arrive one by one with all their incident edges. The goal is to maintain a maximum matching while minimizing the number of changes (replacements) to the matching. We show that the greedy algorithm that always takes the shortest augmenting path from the newly inserted vertex (denoted the SAP protocol) uses at most amortized replacements per insertion, where n is the total number of vertices inserted. This is the first analysis to achieve a polylogarithmic number of replacements for any replacement strategy, almost matching the Ω(log n ) lower bound. The previous best strategy known achieved amortized replacements [Bosek, Leniowski, Sankowski, Zych, FOCS 2014]. For the SAP protocol in particular, nothing better than then trivial bound was known except in special cases. Our analysis immediately implies the same upper bound of reassignments for the capacitated assignment problem, where each vertex on the static side of the bipartition is initialized with the capacity to serve a number of vertices. We also analyze the problem of minimizing the maximum server load. We show that if the final graph has maximum server load L, then the SAP protocol makes amortized reassignments. We also show that this is close to tight because reassignments can be necessary.

SODA Conference 2017 Conference Paper

Deterministic Partially Dynamic Single Source Shortest Paths for Sparse Graphs

  • Aaron Bernstein
  • Shiri Chechik

In this paper we consider the decremental single-source shortest paths (SSSP) problem, where given a graph G and a source node s the goal is to maintain shortest paths between s and all other nodes in G under a sequence of online adversarial edge deletions. (Our algorithm can also be modified to work in the incremental setting, where the graph is initially empty and subject to a sequence of online adversarial edge insertions.) In their seminal work, Even and Shiloach [JACM 1981] presented an exact solution to the problem with only O ( mn ) total update time over all edge deletions. Later papers presented conditional lower bounds showing that O ( mn ) is optimal up to log factors. In SODA 2011, Bernstein and Roditty showed how to bypass these lower bounds and improve upon the Even and Shiloach O (m n ) total update time bound by allowing a (1 + ∊) approximation. This triggered a series of new results, culminating in a recent breakthrough of Henzinger, Krinninger and Nanongkai [FOCS 14], who presented a (1 + ∊)-approximate algorithm whose total update time is near linear: However, every single one of these improvements over the Even-Shiloach algorithm was randomized and assumed a non-adaptive adversary. This additional assumption meant that the algorithms were not suitable for certain settings and could not be used as a black box data structure. Very recently Bernstein and Chechik presented in STOC 2016 the first deterministic improvement over Even and Shiloach, that did not rely on randomization or assumptions about the adversary: in an undirected unweighted graph the algorithm maintains (1+ ∊)-approximate distances and has total update time O ( n 2 ). In this paper, we present a new deterministic algorithm for the problem with total update time Õ ( n 1. 25 √ m ) = Õ (mn 3/4 ): it returns a (1 + ∊) approximation, and is limited to undirected unweighted graphs. Although this result is still far from matching the randomized near-linear total update time, it presents important progress towards that direction, because unlike the STOC 2016 Õ ( n 2 ) algorithm it beats the Even and Shiloach Õ ( mn ) bound for all graphs, not just sufficientl6y dense ones. In particular, the Õ ( n 2 ) algorithm relied entirely on a new sparsification technique, and so could not hope to yield an improvement for sparse graphs. We present the first deterministic improvement for sparse graphs by significantly extending some of the ideas from the Õ ( n 2 ) algorithm and combining them with the hop-set technique used in several earlier dynamic shortest path papers. Also, because decremental single source shortest paths is often used as a building block for fully dynamic all pairs shortest paths, using our new algorithm as a black box yields new deterministic algorithms for fully dynamic approximate all pairs shortest paths.

STOC Conference 2016 Conference Paper

Deterministic decremental single source shortest paths: beyond the o(mn) bound

  • Aaron Bernstein
  • Shiri Chechik

In this paper we consider the decremental single-source shortest paths (SSSP) problem, where given a graph G and a source node s the goal is to maintain shortest paths between s and all other nodes in G under a sequence of online adversarial edge deletions. In their seminal work, Even and Shiloach [JACM 1981] presented an exact solution to the problem with only O ( mn ) total update time over all edge deletions. Their classic algorithm was the best known result for the decremental SSSP problem for three decades, even when approximate shortest paths are allowed. The first improvement over the Even-Shiloach algorithm was given by Bernstein and Roditty [SODA 2011], who for the case of an unweighted and undirected graph presented an approximate (1+) algorithm with constant query time and a total update time of O ( n 2+ O (1/√log n ) ). This work triggered a series of new results, culminating in a recent breakthrough of Henzinger, Krinninger and Nanongkai [FOCS 14], who presented a -approximate algorithm whose total update time is near linear O ( m 1+ O (1/√log n ) ). In this paper they posed as a major open problem the question of derandomizing their result. In fact, all known improvements over the Even-Shiloach algorithm are randomized. All these algorithms maintain some truncated shortest path trees from a small subset of nodes. While in the randomized setting it is possible to “hide” these nodes from the adversary, in the deterministic setting this is impossible: the adversary can delete all edges touching these nodes, thus forcing the algorithm to choose a new set of nodes and incur a new computation of shortest paths. In this paper we present the first deterministic decremental SSSP algorithm that breaks the Even-Shiloach bound of O ( mn ) total update time, for unweighted and undirected graphs. Our algorithm is (1 + є) approximate and achieves a total update time of Õ( n 2 ). Our algorithm can also achieve the same bounds in the incremental setting. It is worth mentioning that for dense instances where m = Ω( n 2 − 1/√log( n ) ), our algorithm is also faster than all existing randomized algorithms.

SODA Conference 2016 Conference Paper

Faster Fully Dynamic Matchings with Small Approximation Ratios

  • Aaron Bernstein
  • Cliff Stein 0001

Maximum cardinality matching is a fundamental algorithmic problem with many algorithms and applications. The fully dynamic version, in which edges are inserted and deleted over time has also been the subject of much attention. Existing algorithms for dynamic matching (in general n -vertex m -edge graphs) fall into two groups: there are fast (mostly randomized) algorithms that achieve a 2-approximation or worse, and there are slow algorithms with update time that achieve a better-than-2 approximation. Thus the obvious question is whether we can design an algorithm that achieves a tradeoff between these two: a update time and a better-than-2 approximation simultaneously. We answer this question in the affirmative. Previously, such bounds were only known for the special case of bipartite graphs. Our main result is a fully dynamic deterministic algorithm that maintains a (3/2 + ∊)-approximation in amortized update time O ( m 1/4∊–2. 5 ). In addition to achieving the trade-off described above, our algorithm manages to be polynomially faster than all existing deterministic algorithms (excluding an existing log n -approximation of Onak and Rubinfeld), while still maintaining a better-than-2 approximation. We also give stronger results for graphs whose arboricity is at most α. We show how to maintain a (1 + ∊)-approximate fractional matching or a (3/2 + ∊)-approximate integral matching in worst-case time O ( α ( α + log n )) for constant ∊. When the arboricity is constant, this bound is O (log n ) and when the arboricity is polylogarithmic the update time is also polylogarithmic. Previous results for small arboricity non-bipartite graphs could only maintain a maximal matching (2-approximation). We maintain the approximate matching without explicitly using augmenting paths. We define an intermediate graph, called an EDCS and show that the EDCS H contains a large matching, and show how to maintain an EDCS in G. The EDCS was used in previous works on bipartite graphs, however the details and proofs are completely different in general graphs. The algorithm for bipartite graphs relies on ideas from flows and cuts to non-constructively prove the existence of a good matching in H, but these ideas do not seem to extend to non-bipartite graphs. In this paper we instead explicitly construct a large fractional matching in H. In some cases we can guarantee that this fractional matching is γ-restricted, which means that it only uses values either in the range [0, γ] or 1. We then combine this matching with a new structural property of maximum matchings in non-bipartite graphs, which is analogous to the cut induced by maximum matchings in bipartite graphs.

STOC Conference 2013 Conference Paper

Maintaining shortest paths under deletions in weighted directed graphs: [extended abstract]

  • Aaron Bernstein

We present an improved algorithm for maintaining all-pairs 1 + ε approximate shortest paths under deletions and weight-increases. The previous state of the art for this problem was total update time ~O (n 2 √m/ε) for directed, unweighted graphs [2], and ~O(mn/ε) for undirected, unweighted graphs [12]. Both algorithms were randomized and had constant query time. Note that ~O(mn) is a natural barrier because even with a (1 + ε) approximation, there is no o(mn) combinatorial algorithm for the static all-pairs shortest path problem. Our algorithm works on directed, weighted graphs and has total (randomized) update time ~O (mn log(R)/ε) where R is the ratio of the largest edge weight ever seen in the graph, to the smallest such weight (our query time is constant). Note that log(R) = O(log(n)) as long as weights are polynomial in n. Although ~O(mn log(R)/ε) is the total time over all updates, our algorithm also requires a clearly unavoidable constant time per update. Thus, we effectively expand the ~O(mn) total update time bound from undirected, unweighted graphs to directed graphs with polynomial weights. This is in fact the first non-trivial algorithm for decremental all-pairs shortest paths that works on weighted graphs (previous algorithms could only handle small integer weights). By a well known reduction from decremental algorithms to fully dynamic ones [9], our improved decremental algorithm leads to improved query-update tradeoffs for fully dynamic (1 + ε) approximate APSP algorithm in directed graphs.

SODA Conference 2010 Conference Paper

A Nearly Optimal Algorithm for Approximating Replacement Paths and k Shortest Simple Paths in General Graphs

  • Aaron Bernstein

Let G = ( V, E ) be a directed graph with positive edge weights, let s, t be two specified vertices in this graph, and let π( s, t ) be the shortest path between them. In the replacement paths problem we want to compute, for every edge e on π( s, t ), the shortest path from s to t that avoids e. The naive solution to this problem would be to remove each edge e, one at a time, and compute the shortest s – t path each time; this yields a running time of O ( mn + n log n ). Gotthilf and Lewenstein [8] recently improved this to O ( mn + n 2 log log n ), but no o ( mn ) algorithms are known. We present the first approximation algorithm for replacement paths in directed graphs with positive edge weights. Given any ε ∊ [0, 1), our algorithm returns (1 + ε)-approximate replacement paths in time, where C is the largest edge weight in the graph and c is the smallest weight. We also present an even faster (1 + ε) approximate algorithm for the simpler problem of approximating the k shortest simple s – t paths in a directed graph with positive edge weights. That is, our algorithm outputs k different simple s – t paths, where the kth path we output is a (1 + ε) approximation to the actual kth shortest simple s – t path. The running time of our algorithm is. The fastest exact algorithm for this problem has a running time of [8]. The previous best approximation algorithm was developed by Roditty [15]; it has a stretch of 3/2 and a running time of (it does not work for replacement paths). Note that all of our running times are nearly optimal except for the O (log( nC / c )) factor in the replacements paths algorithm. Also, our algorithm can solve the variant of approximate replacement paths where we avoid vertices instead of edges.

STOC Conference 2009 Conference Paper

A nearly optimal oracle for avoiding failed vertices and edges

  • Aaron Bernstein
  • David R. Karger

We present an improved oracle for the distance sensitivity problem. The goal is to preprocess a directed graph G = (V,E) with non-negative edge weights to answer queries of the form: what is the length of the shortest path from x to y that does not go through some failed vertex or edge f. The previous best algorithm produces an oracle of size ~O(n 2 ) that has an O(1) query time, and an ~O(n 2 √m) construction time. It was a randomized Monte Carlo algorithm that worked with high probability. Our oracle also has a constant query time and an ~O(n 2 ) space requirement, but it has an improved construction time of ~O(mn), and it is deterministic. Note that O(1) query, O(n 2 ) space, and O(mn) construction time is also the best known bound (up to logarithmic factors) for the simpler problem of finding all pairs shortest paths in a weighted, directed graph. Thus, barring improved solutions to the all pairs shortest path problem, our oracle is optimal up to logarithmic factors.

FOCS Conference 2009 Conference Paper

Fully Dynamic (2 + epsilon) Approximate All-Pairs Shortest Paths with Fast Query and Close to Linear Update Time

  • Aaron Bernstein

For any fixed 1 > ¿ > 0 we present a fully dynamic algorithm for maintaining (2 + ¿)-approximate all-pairs shortest paths in undirected graphs with positive edge weights. We use a randomized (Las Vegas) update algorithm (but a deterministic query procedure), so the time given is the expected amortized update time. Our query time O(log log log n). The update time is O¿(mn O(1/¿(log n)) log (nR)), where R is the ratio between the heaviest and the lightest edge weight in the graph (so R = 1 in unweighted graphs). Unfortunately, the update time does have the drawback of a super-polynomial dependence on e. it grows as (3/¿) (¿(log n/log(3/¿)) ) = n (¿(log(3/¿)/log n)). Our algorithm has a significantly faster update time than any other algorithm with sub-polynomial query time. For exact distances, the state of the art algorithm has an update time of O¿(n 2 ). For approximate distances, the best previous algorithm has a O(kmn 1/k ) update time and returns (2 k - 1) stretch paths. Thus, it needs an update time of O(m¿(n)) to get close to our approximation, and it has to return O(¿(log n)) approximate distances to match our update time.

v2026.09.13