No abstract

In the decremental (1 + )-approximate Single-Source Shortest Path (SSSP) problem, we are given a graph G = (V, E) with n = |V |, m = |E|, undergoing edge deletions, and a distinguished source s ∈ V , and we are asked to process edge deletions efficiently and answer queries for distance estimates dist G (s, v) for each v ∈ V , at any stage, such that s, v). In the decremental (1 + )-approximate All-Pairs Shortest Path (APSP) problem, we are asked to answer queries for distance estimates dist G (u, v) for every u, v ∈ V . In this article, we consider the problems for undirected, unweighted graphs.We present a new deterministic algorithm for the decremental (1 + )-approximate SSSP problem that takes total update time O(mn 0.5+o (1) ). Our algorithm improves on the currently best algorithm for dense graphs by Chechik and Bernstein [STOC 2016] with total update timeÕ(n 2 ) and the best existing algorithm for sparse graphs with running timeÕ(n 1.25 √ m) [SODA 2017] whenever m = O(n 1.5−o(1) ). In order to obtain this new algorithm, we develop several new techniques including improved decremental cover data structures for graphs, a more efficient notion of the heavy/light decomposition framework introduced by Chechik and Bernstein and the first clustering technique to maintain a dynamic sparse emulator in the deterministic setting.As a by-product, we also obtain a new simple deterministic algorithm for the decremental (1+ )-approximate APSP problem with near-optimal total running timeÕ(mn/ ) matching the time complexity of the sophisticated but rather involved algorithm by Henzinger, Forster and Nanongkai [FOCS 2013].

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 + )-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 − )-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.

Given a dynamic digraph G = (V, E) undergoing edge deletions and given s ∈ V and constant ǫ with 0 < ǫ ≤ 1, we consider the problem of maintaining (1 + ǫ)-approximate shortest path distances from s to all vertices in G over the sequence of deletions. Even and Shiloach (J. ACM'81) give a deterministic data structure for the exact version of the problem in unweighted graphs with total update time O(mn). Henzinger et al. (STOC'14, ICALP'15) give a Monte Carlo data structure for the approximate version with an improved total update time bound of O(mn 0.9+o(1) log W ) with better bounds for sufficiently dense and sufficiently sparse graphs; here W is the ratio between the largest and smallest edge weight. A drawback of their data structure and in fact of all previous randomized data structures is that they only work against an oblivious adversary, meaning that the sequence of deletions needs to be fixed in advance. This severely limits its application as a black box inside algorithms. We present the following (1 + ǫ)-approximate data structures:1. the first data structure is Las Vegas and works against an adaptive adversary; it has total expected update timeÕ(m 2/3 n 4/3 ) 1 for unweighted graphs andÕ(m 3/4 n 5/4 log W ) for weighted graphs, 2. the second data structure is Las Vegas and assumes an oblivious adversary; it has total expected update timeÕ( √ mn 3/2 ) for unweighted graphs andÕ(m 2/3 n 4/3 log W ) for weighted graphs, 3. the third data structure is Monte Carlo and is correct w.h.p. against an oblivious adversary; it has total expected update timeÕ((mn) 7/8 log W ) =Õ(mn 3/4 log W ).Each of our data structures can report the length of a (1+ǫ)-approximate shortest path from s to any query vertex in constant time at any point during the sequence of updates; if the adversary is oblivious, a query can be extended to also report such a path in time proportional to its length. Our update times are faster than those of Henzinger et al. for all graph densities. For instance, when m = Θ(n 2 ), our second result improves their bound fromÕ(n 2+3/4+o(1) log W ) toÕ(n 2+1/2 ) in the unweighted setting and toÕ(n 2+2/3 log W ) in the weighted setting. When m = Θ(n), our third result gives an improvement fromÕ(n 1+5/6+o(1) log W ) toÕ(n 1+3/4 log W ). Furthermore, our first data structure is the first to improve on the O(mn) bound of Even and Shiloach for all but the sparsest graphs while still working against an adaptive adversary and works even in weighted graphs; this answers an open problem by Henzinger et al.

We give an algorithm that computes exact maximum flows and minimum-cost flows on directed graphs with m edges and polynomially bounded integral demands, costs, and capacities in m 1+o(1) time. Our algorithm builds the flow through a sequence of m 1+o(1) approximate undirected minimum-ratio cycles, each of which is computed and processed in amortized m o(1) time using a dynamic data structure.Our framework extends to an algorithm running in m 1+o(1) time for computing flows that minimize general edge-separable convex functions to high accuracy. This gives an almost-linear time algorithm for several problems including entropy-regularized optimal transport, matrix scaling, p-norm flows, and isotonic regression.