Improved Space Efficient Algorithms for BFS, DFS and Applications

Abstract

Recent work by Elmasry et al. (STACS 2015) and Asano et al. (ISAAC 2014), reconsidered classical fundamental graph algorithms focusing on improving the space complexity. Elmasry et al. gave, among others, implementations of breadth first search (BFS) and depth first search (DFS) in a graph on n vertices and m edges, taking $O(m+n)$ time using O(n) and $O(n \lg \lg n)$ bits of space respectively improving the naive $O(n \lg n)$(We use $\lg$ to denote logarithm to the base 2.) bits implementation. We continue this line of work focusing on space.

Our first result is a simple data structure that can maintain any subset S of a universe of n elements using $n+o(n)$ bits and support in constant time, apart from the standard insert, delete and membership queries, the operation findany that finds and returns any element of the set (or outputs that the set is empty). Using this we give a BFS implementation that takes $O(m+n)$ time using at most $2n+o(n)$ bits. Later, we further improve the space requirement of BFS to at most $1.585n + o(n)$ bits albeit with a slight increase in running time to $O(m \lg n f(n))$ time where f(n) is any extremely slow growing function of n. These improve the space by a constant factor from earlier representations.

We demonstrate the use of our data structure by developing another data structure using it that can represent a sequence of n non-negative integers $x_1, x_2, \ldots x_n$ using at most $\sum _{i=1}^n x_i + 2n + o(\sum _{i=1}^n x_i+n)$ bits and, in constant time, determine whether the i-th element is 0 or decrement it otherwise. We use this data structure to output the vertices of a

• directed acyclic graph in topological sorted order in $O(m+n)$ time and $O(m+n)$ bits, and

• graph with degeneracy d in degeneracy order in O(nd) time using O(nd) bits.

We also discuss an algorithm for finding a minimum weight spanning tree of a weighted undirected graph using at most $n+o(n)$ bits.

For DFS we give an $O(m+n)$ bits implementation for finding a chain decomposition of a connected undirected graph, and to find cut vertices, bridges and maximal two connected subgraphs of a connected graph. We also provide a O(n) bits implementations for finding strongly connected components of a directed graph, to output the vertices of a directed acyclic graph in a topologically sorted manner, and to find a sparse biconnected subgraph of a biconnected graph. These improve the space required for earlier implementations from $\varOmega (n \lg n)$ bits.