42 research outputs found
A Deterministic Almost-Linear Time Algorithm for Minimum-Cost Flow
We give a deterministic time algorithm that computes exact
maximum flows and minimum-cost flows on directed graphs with edges and
polynomially bounded integral demands, costs, and capacities. As a consequence,
we obtain the first running time improvement for deterministic algorithms that
compute maximum-flow in graphs with polynomial bounded capacities since the
work of Goldberg-Rao [J.ACM '98].
Our algorithm builds on the framework of
Chen-Kyng-Liu-Peng-Gutenberg-Sachdeva [FOCS '22] that computes an optimal flow
by computing a sequence of -approximate undirected minimum-ratio
cycles. We develop a deterministic dynamic graph data-structure to compute such
a sequence of minimum-ratio cycles in an amortized time per edge
update. Our key technical contributions are deterministic analogues of the
vertex sparsification and edge sparsification components of the data-structure
from Chen et al. For the vertex sparsification component, we give a method to
avoid the randomness in Chen et al. which involved sampling random trees to
recurse on. For the edge sparsification component, we design a deterministic
algorithm that maintains an embedding of a dynamic graph into a sparse spanner.
We also show how our dynamic spanner can be applied to give a deterministic
data structure that maintains a fully dynamic low-stretch spanning tree on
graphs with polynomially bounded edge lengths, with subpolynomial average
stretch and subpolynomial amortized time per edge update.Comment: Accepted to FOCS 202
A Dynamic Shortest Paths Toolbox: Low-Congestion Vertex Sparsifiers and their Applications
We present a general toolbox, based on new vertex sparsifiers, for designing
data structures to maintain shortest paths in dynamic graphs.
In an -edge graph undergoing edge insertions and deletions, our data
structures give the first algorithms for maintaining (a) -approximate
all-pairs shortest paths (APSP) with \emph{worst-case} update time
and query time , and (b) a tree that has diameter no larger
than a subpolynomial factor times the diameter of the underlying graph, where
each update is handled in amortized subpolynomial time.
In graphs undergoing only edge deletions, we develop a simpler and more
efficient data structure to maintain a -approximate single-source
shortest paths (SSSP) tree in a graph undergoing edge deletions in
amortized time per update.
Our data structures are deterministic. The trees we can maintain are not
subgraphs of , but embed with small edge congestion into . This is in
stark contrast to previous approaches and is useful for algorithms that
internally use trees to route flow.
To illustrate the power of our new toolbox, we show that our SSSP data
structure gives simple deterministic implementations of flow-routing MWU
methods in several contexts, where previously only randomized methods had been
known.
To obtain our toolbox, we give the first algorithm that, given a graph
undergoing edge insertions and deletions and a dynamic terminal set ,
maintains a vertex sparsifier that approximately preserves distances
between terminals in , consists of at most vertices and edges,
and can be updated in worst-case time .
Crucially, our vertex sparsifier construction allows us to maintain a low
edge-congestion embedding of into , which is needed for our
applications
Dynamic Maxflow via Dynamic Interior Point Methods
In this paper we provide an algorithm for maintaining a
-approximate maximum flow in a dynamic, capacitated graph
undergoing edge additions. Over a sequence of -additions to an -node
graph where every edge has capacity our algorithm runs in
time . To obtain this result we
design dynamic data structures for the more general problem of detecting when
the value of the minimum cost circulation in a dynamic graph undergoing edge
additions obtains value at most (exactly) for a given threshold . Over a
sequence -additions to an -node graph where every edge has capacity
and cost we solve this thresholded
minimum cost flow problem in . Both of our algorithms
succeed with high probability against an adaptive adversary. We obtain these
results by dynamizing the recent interior point method used to obtain an almost
linear time algorithm for minimum cost flow (Chen, Kyng, Liu, Peng, Probst
Gutenberg, Sachdeva 2022), and introducing a new dynamic data structure for
maintaining minimum ratio cycles in an undirected graph that succeeds with high
probability against adaptive adversaries.Comment: 30 page
Simple Dynamic Spanners with Near-Optimal Recourse Against an Adaptive Adversary
Designing dynamic algorithms against an adaptive adversary whose performance match the ones assuming an oblivious adversary is a major research program in the field of dynamic graph algorithms. One of the prominent examples whose oblivious-vs-adaptive gap remains maximally large is the fully dynamic spanner problem; there exist algorithms assuming an oblivious adversary with near-optimal size-stretch trade-off using only polylog(n) update time [Baswana, Khurana, and Sarkar TALG\u2712; Forster and Goranci STOC\u2719; Bernstein, Forster, and Henzinger SODA\u2720], while against an adaptive adversary, even when we allow infinite time and only count recourse (i.e. the number of edge changes per update in the maintained spanner), all previous algorithms with stretch at most log?(n) require at least ?(n) amortized recourse [Ausiello, Franciosa, and Italiano ESA\u2705].
In this paper, we completely close this gap with respect to recourse by showing algorithms against an adaptive adversary with near-optimal size-stretch trade-off and recourse. More precisely, for any k ? 1, our algorithm maintains a (2k-1)-spanner of size O(n^{1+1/k}log n) with O(log n) amortized recourse, which is optimal in all parameters up to a O(log n) factor. As a step toward algorithms with small update time (not just recourse), we show another algorithm that maintains a 3-spanner of size O?(n^{1.5}) with polylog(n) amortized recourse and simultaneously O?(?n) worst-case update time
Dynamic Low-Stretch Trees via Dynamic Low-Diameter Decompositions
Spanning trees of low average stretch on the non-tree edges, as introduced by
Alon et al. [SICOMP 1995], are a natural graph-theoretic object. In recent
years, they have found significant applications in solvers for symmetric
diagonally dominant (SDD) linear systems. In this work, we provide the first
dynamic algorithm for maintaining such trees under edge insertions and
deletions to the input graph. Our algorithm has update time
and the average stretch of the maintained tree is , which matches
the stretch in the seminal result of Alon et al.
Similar to Alon et al., our dynamic low-stretch tree algorithm employs a
dynamic hierarchy of low-diameter decompositions (LDDs). As a major building
block we use a dynamic LDD that we obtain by adapting the random-shift
clustering of Miller et al. [SPAA 2013] to the dynamic setting. The major
technical challenge in our approach is to control the propagation of updates
within our hierarchy of LDDs: each update to one level of the hierarchy could
potentially induce several insertions and deletions to the next level of the
hierarchy. We achieve this goal by a sophisticated amortization approach.
We believe that the dynamic random-shift clustering might be useful for
independent applications. One of these applications is the dynamic spanner
problem. By combining the random-shift clustering with the recent spanner
construction of Elkin and Neiman [SODA 2017]. We obtain a fully dynamic
algorithm for maintaining a spanner of stretch and size with amortized update time for any integer . Compared to the state-of-the art in this regime
[Baswana et al. TALG '12], we improve upon the size of the spanner and the
update time by a factor of .Comment: To be presented at the 51st Annual ACM Symposium on the Theory of
Computing (STOC 2019); abstract shortened to respect the arXiv limit of 1920
character
Connectivity Oracles for Graphs Subject to Vertex Failures
We introduce new data structures for answering connectivity queries in graphs
subject to batched vertex failures. A deterministic structure processes a batch
of failed vertices in time and thereafter
answers connectivity queries in time. It occupies space . We develop a randomized Monte Carlo version of our data structure
with update time , query time , and space
for any failure bound . This is the first connectivity oracle for
general graphs that can efficiently deal with an unbounded number of vertex
failures.
We also develop a more efficient Monte Carlo edge-failure connectivity
oracle. Using space , edge failures are processed in time and thereafter, connectivity queries are answered in
time, which are correct w.h.p.
Our data structures are based on a new decomposition theorem for an
undirected graph , which is of independent interest. It states that
for any terminal set we can remove a set of
vertices such that the remaining graph contains a Steiner forest for with
maximum degree