Incremental algorithms for minimal length paths
Journal of Algorithms
An incremental algorithm for a generalization of the shortest-path problem
Journal of Algorithms
Fast Algorithms for Constructing t-Spanners and Paths with Stretch t
SIAM Journal on Computing
Near-Linear Time Construction of Sparse Neighborhood Covers
SIAM Journal on Computing
Fast Estimation of Diameter and Shortest Paths (Without Matrix Multiplication)
SIAM Journal on Computing
An On-Line Edge-Deletion Problem
Journal of the ACM (JACM)
All-Pairs Almost Shortest Paths
SIAM Journal on Computing
Journal of Algorithms
Computing almost shortest paths
Proceedings of the twentieth annual ACM symposium on Principles of distributed computing
Improved decremental algorithms for maintaining transitive closure and all-pairs shortest paths
STOC '02 Proceedings of the thiry-fourth annual ACM symposium on Theory of computing
All pairs shortest paths using bridging sets and rectangular matrix multiplication
Journal of the ACM (JACM)
Maintaining all-pairs approximate shortest paths under deletion of edges
SODA '03 Proceedings of the fourteenth annual ACM-SIAM symposium on Discrete algorithms
A Space Saving Trick for Directed Dynamic Transitive Closure and Shortest Path Algorithms
COCOON '01 Proceedings of the 7th Annual International Conference on Computing and Combinatorics
Fully dynamic biconnectivity and transitive closure
FOCS '95 Proceedings of the 36th Annual Symposium on Foundations of Computer Science
Fully Dynamic Algorithms for Maintaining All-Pairs Shortest Paths and Transitive Closure in Digraphs
FOCS '99 Proceedings of the 40th Annual Symposium on Foundations of Computer Science
$(1 + \epsilon,\beta)$-Spanner Constructions for General Graphs
SIAM Journal on Computing
Dynamic Approximate All-Pairs Shortest Paths in Undirected Graphs
FOCS '04 Proceedings of the 45th Annual IEEE Symposium on Foundations of Computer Science
A new approach to dynamic all pairs shortest paths
Journal of the ACM (JACM)
Journal of the ACM (JACM)
Worst-case update times for fully-dynamic all-pairs shortest paths
Proceedings of the thirty-seventh annual ACM symposium on Theory of computing
Spanners and emulators with sublinear distance errors
SODA '06 Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm
Fully dynamic all pairs shortest paths with real edge weights
Journal of Computer and System Sciences - Special issue on FOCS 2001
FOCS '09 Proceedings of the 2009 50th Annual IEEE Symposium on Foundations of Computer Science
Fully dynamic approximate distance oracles for planar graphs via forbidden-set distance labels
STOC '12 Proceedings of the forty-fourth annual ACM symposium on Theory of computing
Facilitating real-time graph mining
Proceedings of the fourth international workshop on Cloud data management
Maintaining shortest paths under deletions in weighted directed graphs: [extended abstract]
Proceedings of the forty-fifth annual ACM symposium on Theory of computing
Sublinear-Time maintenance of breadth-first spanning tree in partially dynamic networks
ICALP'13 Proceedings of the 40th international conference on Automata, Languages, and Programming - Volume Part II
Hi-index | 0.00 |
We present the first dynamic shortest paths algorithms that make any progress beyond a long-standing O(n) update time barrier (while maintaining a reasonable query time), although it is only progress for not-too-sparse graphs. In particular, we obtain new decremental algorithms for two approximate shortest-path problems in unweighted, undirected graphs. Both algorithms are randomized (Las Vegas). • Given a source s, we present an algorithm that maintains (1 + ε)-approximate shortest paths from s with an expected total update time of Õ(n2+O(1/√log n)) over all deletions (so the amortized time is about Õ(n2/m)). The worst-case query time is constant. The best previous result goes back three decades to Even and Shiloach [16] and Dinitz [12]. They show how to decrementally maintain an exact shortest path tree with a total update time of O(mn) (amortized update time O(n)). Roditty and Zwick [22] have shown that O(mn) is actually optimal for exact paths (barring a better combinatorial algorithm for boolean matrix multiplication), unless we are willing to settle for a Ω(n) query time. In fact, until now, even approximate dynamic algorithms were not able to go beyond O(mn). • For any fixed integer k ≥ 2, we present an algorithm that decrementally maintains a distance oracle (for all pairs shortest distances) with a total expected update time of Õ(n2+1/k+O(1/√log n)) (amortized update time about Õ(n2+1/k/m). The space requirement is only O(m + n1+1/k), the stretch of the returned distances is at most 2k − 1 + ε, and the worst-case query time is O(1). The best previous result of Roditty and Zwick [21] had a total update time of Õ(mn) and a stretch of 2k − 1. Note that our algorithm implicitly solves the decremental all-pairs shortest path problem with the same bounds; the best previous approximation algorithm of Roditty and Zwick [21] returned (1 + ε) approximate distances, but used O(n2) space, and required Õ(mn) total update time. As with the previous problem, our algorithm is the first to make progress beyond the O(mn) total update time barrier while maintaining a small query time. We present a general framework for accelerating decremental algorithms. In particular, our main idea is to run existing decremental algorithms on a sparse subgraph (such as a spanner or emulator) of the graph rather than on the original graph G. Although this is a common approach for static approximate shortest-path problems, it has never been used in a decremental setting because maintaining the subgraph H as edges are being deleted from G might require inserting edges into H, thus ruining the "decrementality" of the setting. We overcome this by presenting an emulator whose maintenance only requires a limited number of well-behaved insertions. In other words, we present a general technique for running decremental algorithms on a sparse subgraph of the graph. Once our framework is in place, applying it to any particular decremental algorithm only requires trivial modifications; most of the work consists of showing that these algorithms as they are still work in our restricted fully dynamic setting, where we encounter not just arbitrary deletions (as in the original setting), but also restricted insertions.