Sensitive Distance and Reachability Oracles for Large Batch Updates

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
²
+ Wnf
^ω
) update time, and Õ(Wn
^2-μ
f + Wnf
²
) 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
²
) query time. This data-structure requires O(n
²
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].