Space-Efficient Depth-First Search via Augmented Succinct Graph Encodings

TL;DR

This work develops a space-efficient framework for performing depth-first search on separable graphs by introducing a succinct nested-division encoding. The core idea is to partition graphs into multi-scale pieces with boundary vertices that mediate inter-piece interactions, enabling a DFS from any start vertex in $o(n)$ time with $o(n)$ extra bits and embedding the DFS tree for constant-time related queries. The approach combines recursive divisions, boundary-vertex translation mappings via fully indexable dictionaries, and augmentations that store limited, carefully chosen meta-information in a strongly local fashion. For planar graphs, the authors show linear-time, linear-space construction and offer a compact variant, broadening practical applicability to a broad class of sparse graphs. Overall, the paper delivers a practical, sublinear-space DFS framework with direct support for common DFS-associated queries, benefiting algorithms that need meta-information such as $s$-$t$ numbering, lowpoints, and LCAs without incurring large memory overhead.

Abstract

We call a graph $G$ separable if a balanced separator can be computed for $G$ of size $O(n^c)$ with $c<1$. Many real-world graphs are separable such as graphs of bounded genus, graphs of constant treewidth, and graphs excluding a fixed minor $H$. In particular, the well-known planar graphs are separable. We present a succinct encoding of separable graphs $G$ such that any number of depth-first searches DFS can be performed, from any given start vertex, each in $o(n)$ time with $o(n)$ additional bits. After the execution of a DFS, the succinct encoding of $G$ is augmented such that the DFS tree is encoded inside the encoding. Afterward, the encoding provides common DFS-related queries in constant time. These queries include queries such as lowest-common ancestor of two given vertices in the DFS tree or queries that output the lowpoint of a given vertex in the DFS tree. Furthermore, for planar graphs, we show that the succinct encoding can be computed in $O(n)$ bits and expected linear time, and a compact variant can be constructed in $O(n)$ time and bits.

Figures (4)

• Figure 1: A sketch of a division of graph into $6$ pieces of at most $13$ vertices. The edges of each piece are colored with a distinct color. Boundary vertices are gray squares, and non-boundary vertices black circles. Non-boundary edges are solid, transitional edges dotted, and boundary edges dashed.
• Figure 2: Initially the micro piece $P_{i, j}$ is stored as an index $x$ of the table lookup, sketched below with two entries explicitly shown. The graph shown in the table has regular vertices shown as circles, and the vertices for which we can store binary strings shown as rectangles, e.g., micro boundary vertices in the piece $P_{i, j}$. Additionally, we have a list $L$ for each graph of the table that has enough capacity to store some values. We execute a query that takes as input the index $x$, the vertex label $4$ and color $c$ to assign to vertex $4$. It returns the index $y$ of the lookup table such that $y$ stores the state that represents the execution of this query when applied to the graph stored at index $x$. We then swap the index $x$ stored for $P_{i, j}$ with the index $y$ in our succinct nested division.
• Figure 3: From left to right, the figure shows four DFS states of some piece $P$. In the first state, no vertex inside $P$ is visited yet, and we have just arrived at a boundary vertex of $P$ (colored red). We then advance the DFS until the next boundary vertex is visited, colored violet. For micro pieces, we advance it via one query to the lookup table. We later arrive at the same piece again, this time via the blue boundary vertex. We enter the piece, and encounter the situation of the null-exit, thus we fully explore all vertices belonging to the subtree rooted at the blue vertex. Finally, we backtrack to the piece $P$ via the violet vertex, and see that there is a part of the piece not yet visited. We advance the state until the orange boundary vertex is visited and leave the piece again. The entry-exit pairs of the piece are $(\ {\color{red}{\put(0,.63){\circle*{1.5}}}}\ , \ {\color{violet}{\put(0,.63){\circle*{1.5}}}}\ )$, $(\ {\color{blue}{\put(0,.63){\circle*{1.5}}}}\ ,\ {\texttt{null}})$ and $(\ {\color{red}{\put(0,.63){\circle*{1.5}}}}\ ,\ {\color{orange}{\put(0,.63){\circle*{1.5}}}}\ )$. Tree edges are shown as solid lines, and back edges as dotted lines.
• Figure 4: Lowpoints (a) The figure shows a piece and sketched parts of the DFS tree. Boundary vertices are drawn as squares, non-boundary vertices as circles, vertices of undefined type as diamonds. The lowpoint of the red non-boundary vertex is the red boundary vertex. The lowpoint of the blue non-boundary vertex is the blue diamond vertex. LCAs (b) The right figures shows two pieces. The LCA of the blue vertex and the violet vertex is the same as the LCA of the green and the red vertex. The LCA of the blue and the orange vertex is the green vertex. We can see that the LCA of two vertices in different pieces can be reduced to the LCA of two boundary vertices of the respective pieces.

Theorems & Definitions (10)

• Theorem 1
• Corollary 2
• Definition 3: Relaxed Division
• Definition 4: Nested Division
• Lemma 5: BlellochF10
• Lemma 6: Fully Indexable Dictionary (FID) BaumannH19
• Lemma 7: Succinct Nested Division,BlellochF10
• Corollary 8: Compact Nested Division
• Lemma 10
• Lemma 11