학술논문

Sensitive Distance and Reachability Oracles for Large Batch Updates
Document Type
Conference
Source
2019 IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS) Foundations of Computer Science (FOCS), 2019 IEEE 60th Annual Symposium on. :424-435 Nov, 2019
Subject
Computing and Processing
Directed graphs
Data structures
Monte Carlo methods
Roads
Kernel
Matrix decomposition
Shortest path problem
sensitive oracle
emergency oracle
failure
batch
reachability
distance
Language
ISSN
2575-8454
Abstract
In the sensitive distance oracle problem, there are three phases. We first preprocess a given directed graph G with n nodes and integer weights from [-W,W]. Second, given a single batch of f edge insertions and deletions, we update the data structure. Third, given a query pair of nodes (u,v), return the distance from u to v. In the easier problem called sensitive reachability oracle problem, we only ask if there exists a directed path from u to v. Our first result is a sensitive distance oracle with Õ(Wn^ω+(3-ω)µ) preprocessing time, Õ(Wn^2-µ f^2+Wnf^ω) update time, and Õ(Wn^2-µ f+Wnf^2) query time where the parameter µ∊[0,1] can be chosen. The data-structure requires O(Wn^2+µ log n) bits of memory. This is the first algorithm that can handle f≥log n updates. Previous results (e.g. [Demetrescu et al. SICOMP'08; Bernstein and Karger SODA'08 and FOCS'09; Duan and Pettie SODA'09; Grandoni and Williams FOCS'12]) can handle at most 2 updates. When 3≤ f≤log n, the only non-trivial algorithm was by [Weimann and Yuster FOCS'10]. When W=Õ(1), our algorithm simultaneously improves their preprocessing time, update time, and query time. In particular, when f=ω(1), their update and query time is Ω(n^2-o(1)), while our update and query time are truly subquadratic in n, i.e., ours is faster by a polynomial factor of n. To highlight the technique, ours is the first graph algorithm that exploits the kernel basis decomposition of polynomial matrices by [Jeannerod and Villard J.Comp'05; Zhou, Labahn and Storjohann J.Comp'15] developed in the symbolic computation community. As an easy observation from our technique, we obtain the first sensitive reachability oracle can handle f≥log n updates. Our algorithm has O(n^ω) preprocessing time, O(f^ω) update time, and O(f^2) query time. This data-structure requires O(n^2 log n) bits of memory. Efficient sensitive reachability oracles were asked in [Chechik, Cohen, Fiat, and Kaplan SODA'17]. Our algorithm can handle any constant number of updates in constant time. Previous algorithms with constant update and query time can handle only at most f≤2 updates. Otherwise, there are non-trivial results for f≤log n, though, with query time Ω(n) by adapting [Baswana, Choudhary and Roditty STOC'16].