Connectivity Queries Under Vertex Failures: Not Optimal, but Practical

We revisit once more the problem of designing an oracle for answering connectivity queries in undirected graphs in the presence of vertex failures. Specifically, given an undirected graph G with n vertices and m edges and an integer d_⋆ ≪ n, the goal is to preprocess the graph in order to construct a data structure 𝒟 such that, given a set of vertices F with |F| = d ≤ d_⋆, we can derive an oracle from 𝒟 that can efficiently answer queries of the form "is x connected with y in G⧵F?". Very recently, Long and Saranurak (FOCS 2022) provided a solution to this problem that is almost optimal with respect to the preprocessing time, the space usage, the update time, and the query time. However, their solution is highly complicated, and it seems very difficult to be implemented efficiently. Furthermore, it does not settle the complexity of the problem in the regime where d_⋆ is a constant. Here, we provide a much simpler solution to this problem, that uses only textbook data structures. Our algorithm is deterministic, it has preprocessing time and space complexity O(d_⋆ m log n), update time O(d⁴ log n), and query time O(d). These bounds compare very well with the previous best, especially considering the simplicity of our approach. In fact, if we assume that d_⋆ is a constant (d_⋆ ≥ 4), then our algorithm provides some trade-offs that improve the state of the art in some respects. Finally, the data structure that we provide is flexible with respect to d_⋆: it can be adapted to increases and decreases, in time and space that are almost proportional to the change in d_⋆ and the size of the graph.