Optimal In-place Algorithms for Basic Graph Problems

TL;DR

This paper introduces linear-time in-place algorithms for fundamental graph problems, significantly improving previous results and exploiting input graph sortedness for efficiency.

Contribution

It presents the first linear-time in-place algorithms for various core graph problems, surpassing prior polynomial-time solutions.

Findings

Algorithms run in linear time, optimal for the problems addressed.

Exploiting input sortedness is key to achieving in-place efficiency.

The techniques may apply to other graph problems in the future.

Abstract

We present linear time {\it in-place} algorithms for several basic and fundamental graph problems including the well-known graph search methods (like depth-first search, breadth-first search, maximum cardinality search), connectivity problems (like biconnectivity, $2$-edge connectivity), decomposition problem (like chain decomposition) among various others, improving the running time (by polynomial multiplicative factor) of the recent results of Chakraborty et al. [ESA, 2018] who designed $O(n^3 \lg n)$ time in-place algorithms for a strict subset of the above mentioned problems. The running times of all our algorithms are essentially optimal as they run in linear time. One of the main ideas behind obtaining these algorithms is the detection and careful exploitation of sortedness present in the input representation for any graph without loss of generality. This observation alone is powerful enough to design some basic linear time in-place algorithms, but more non-trivial graph problems require extra techniques which, we believe, may find other applications while designing in-place algorithms for different graph problems in the future.

Full text

1. Introduction

Inspired by the speedy growth of humongous data set (“big data phenomenon"), space efficient algorithms are becoming increasingly more crucial than ever before. The dire need of such algorithms is also propelled by the pervasive usage of small specialized handheld devices and embedded systems which come equipped with tiny memory. To design such algorithms a vast array of computational models has already been proposed in the literature. In what follows, we briefly mention a few of them in the order they are historically developed.

In the read-only memory model (henceforth ROM) where the input is read-only, output is write only, and a limited sized random access read/write work space is available, researchers have designed space efficient algorithms for selection and sorting [14, 27, 34, 41, 42], problems in computational geometry [2, 4, 6, 13, 18], and graphs [3, 5, 11, 26] among various others. In the in-place model, it is assumed that the input elements are given in an array, and the algorithm may use the input array as working space, hence the algorithm is allowed to modify the array during its execution. However, after the execution all the input elements should be present in the array and the output maybe put in the same array or sent to an output stream. The extra space usage during the entire execution of the algorithm is limited to $O(\lg n)$ bits only. A prime example of an in-place algorithm is the classic heap-sort. Other than in-place sorting [33], searching [31, 39] and selection [37], many in-place algorithms were designed in areas such as computational geometry [8] and string algorithms [32]. A very recent addition to this long list is the in-place algorithms for the graph problems [10]. Other than these, researchers have also designed space efficient algorithms in (semi)-streaming models [1, 30, 41] and recently introduced restore [15] and catalytic-space [9] models.

1.1. Previous Work on Space Efficient Graph Algorithms

In this paper we exclusively deal with space efficient algorithms for graph theoretic problems. Recent study of space efficient graph algorithms in the streaming and semi-streaming models focused on fundamental problems like connectivity, minimum spanning tree, matching etc. See [38] for a detailed survey concerning these results. However study of such algorithms in ROM dates back to almost 40 years. In fact there already exists a very rich history of extremely space efficient graph algorithms in ROM, and this is captured by the complexity class L which contains decision problems that can be solved by a deterministic Turing machine using only logarithmic amount of work space. A plethora of important algorithmic graph problems actually admit an L algorithm [19, 22, 23, 24], and the most famous among these is the Reingold’s [44] method for checking st-reachability in undirected graphs. In spite of being optimally space efficient, a major drawback of these algorithms is that their running time is most often some polynomial of very high degree, and this fact is not surprising, given the results of [21, 51] (which state that for problems like directed st-reachability, if the number of bits available is $o(n)$, then some of the natural algorithmic approaches would require super-polynomial time). This fact alone hinders the practicality of these algorithms in applications. Motivated by this problem, and inspired by the pervasive practical applications of the fundamental graph algorithms, recently there has been a surge of interest in improving the space complexity of graph algorithms without paying too much penalty in the running time i.e., reducing the working space of the classical graph algorithms to $O(n)$ bits with little or no penalty in running time. Thus the goal is to design space-efficient yet reasonably time-efficient graph algorithms on the ROM. Generally most of the standard implementations of classical graph algorithms take linear or near-linear running time and use $O(n\lg n)$ (or sometimes $O(m\lg n)$ for graphs with $n$ vertices and $m$ edges) bits. A recent series of papers [3, 5, 11, 12, 26] with this point of view showed such results for a vast array of basic graph problems, namely depth-first search (henceforth DFS), breadth-first search (henceforth BFS), minimum spanning tree (henceforth MST), (strong) connectivity, topological sorting, recognizing chordal graphs, bi-connectivity, st-numbering, shortest path and many others.

Even if these results are still both time and space efficient, it seems to still require $\Theta(n)$ bits for most of important graph algorithms, and this is a major concern in places with severe space constraints. In order to break this inherent space bound barrier and still obtain reasonable time efficiency, Chakraborty et al. [10] initiated a systematic study of designing efficient in-place (i.e., using $O(\lg n)$ bits of extra space other than the input space) algorithms for graph problems by defining a new framework which is a slight relaxation of the ROM. Using this framework they were also able to show in-place DFS, BFS, MST, reachability algorithms taking time $O(n^{3}\lg n)$. Despite being optimal in space usage, observe that these results still leave a polynomial gap in the running time from the optimal value. In this work, we essentially obtain the best of the both worlds by closing this gap. More specifically, we show how one can design optimal in-place algorithms i.e., $O(m+n)$ time and using $O(\lg n)$ bits of extra space, for several of these (and a lot more) basic graph algorithms in this work. Recently Kammer et al. [35] also considered a similar model where they showed efficient in-place algorithms for DFS, unordered-BFS (will be defined shortly) only.

1.2. In-place Model for Graph Algorithms and Input Representations

Before explaining our in-place algorithms and stating main results, in this section we first describe the input graph representation. Note that, as in the case of the standard in-place model, we need to ensure that the graph (adjacency) structure must remain intact throughout entire execution of the algorithm. Let $G=(V,E)$ be the input graph with $n=|V|$, $m=|E|$, and as usual let $V=\{1,2,\cdots,n\}$ denote the vertex set of $G$. We assume that the input graph is given in the standard adjacency array format, and throughout this paper, we refer to this array as $Z$. More specifically, it is an array having size $(n+m+1)$ ($(n+2m+1)$ resp.) words for directed (undirected resp.) graphs where $Z[1]$ stores the number of vertices in $G$, the next $n$ entries (which we refer to as the offsets part of $Z$) store $n$ pointers (one per vertex) pointing to the location in $Z$ of the last neighbor for each vertex, and finally the last $m$ ($2m$ for undirected graphs) entries are reserved for the edges of $G$. At this point, we should emphasize a small, yet important, technical detail. The $Z$ array can be thought of as a single bit array as follows. For a directed graph $G$, the array $Z$ is a concatenation of $Z[1]$ of length $\left\lceil\lg n\right\rceil$ bits, $Z[2]\ldots Z[n+1]$ of length $\left\lceil\lg m\right\rceil$ bits each111Note that it is enough to store the offset values starting from [math], since we can add $n+1$ to the offset value to find the corresponding location in $Z$; hence the offset values can be stored using $\left\lceil\lg m\right\rceil$ bits., and finally $Z[n+2]\ldots Z[n+m+1]$ of length $\left\lceil\lg n\right\rceil$ bits each. For undirected graphs, only the second part changes to size $\left\lceil\lg m\right\rceil+1$ bits (instead of $\left\lceil\lg m\right\rceil$) each. Thus, if we just remember the boundaries, we know exactly how many bits we need to read in order to extract useful information from the relevant parts of $Z$. For the sake of simplicity, we drop the ceiling notations from now on. Moreover, throughout this paper, it should be clear from the context the word size depending on which part of $Z$ we are currently working on. See Figure 1 for an example. Note that this representation implicitly captures the degree information for every vertex in $G$. Given this format, we say an algorithm $\mathcal{A}$ is an in-place algorithm if $\mathcal{A}$ (a) may modify any part of $Z$ during its execution, (b) retains all the initial elements of $Z$ (in any order) when it finishes execution; and (c) uses just $O(\lg n)$ bits of extra space. Our goal is to design such algorithms in this paper for a vast array of fundamental graph problems.

In this paper we assume the standard word RAM model of computation. We count space in terms of number of extra bits used by the algorithm other than the input, and this quantity is referred as “extra space” and “space” interchangeably throughout the paper.

1.3. Graph Terminology and Notations

In general we will assume the knowledge of basic graph theoretic terminology as given in [20] and basic graph algorithms as given in [17]. Still here we collect all the necessary graph theoretic definitions that will be used throughout the paper for quick reference and making the paper self-contained. For BFS traversal that we study here, there are two versions studied in the literature. In the *ordered *BFS (sometimes also known as queue BFS [12]), vertices are extracted from the queue in the first in first out (FIFO) order whereas in the *unordered *BFS [5], vertices can be taken out from the queue in any order as long as no elements are extracted from a higher level of the BFS tree before finishing all the vertices from a lower level of the tree. In this paper, by a BFS/DFS traversal of the input graph $G$, as in [3, 5, 11, 12] we refer to reporting the vertices of $G$ in the BFS/DFS ordering, i.e., in the order in which the vertices are visited for the first time. Tarjan et al. [50] defined another method called maximum cardinality search (MCS) and used this to give a recognition algorithms for chordal graphs. MCS works as follows: assuming that every vertex is unnumbered at the beginning, at each iteration of the execution of MCS, an unnumbered vertex that is adjacent to the most number of numbered vertices is chosen (breaking the ties arbitrarily), and is numbered with the next available label. Thus, the output of the MCS algorithm is a numbering of the vertices from $1$ to $n$.

A cut vertex in an undirected graph $G$ is a vertex $v$ that when removed (along with its incident edges) from a graph creates more components than previously in the graph. A (connected) graph with at least three vertices is biconnected if and only if it has no cut vertex. Similarly in an undirected graph $G$, a bridge is an edge that when removed (without removing the vertices) from a graph creates more components than previously in the graph. A (connected) graph with at least two vertices is $2$-edge-connected if and only if it has no bridge. Given a biconnected graph $G$, and two distinguished vertices $s$ and $t$ in $V$ such that $s\neq t$, $st$-numbering is a numbering of the vertices of the graph so that $s$ gets the smallest number, $t$ gets the largest and every other vertex is adjacent both to a lower-numbered and to a higher-numbered vertex i.e., a numbering $s=v_{1},v_{2},\cdots,v_{n}=t$ of the vertices of $G$ is called an $st$-numbering, if for all vertices $v_{j},1<j<n$, there exist $1\leq i<j<k\leq n$ such that $\{v_{i},v_{j}\},\{v_{j},v_{k}\}\in E$. It is well-known that $G$ is biconnected if and only if, for every edge $\{s,t\}\in E$, it has an $st$-numbering. A topological sort of a directed acyclic graph (DAG) gives a linear ordering of its vertices such that for every directed edge $(u,v)\in E$ from vertex $u$ to vertex $v$, $u$ comes before $v$ in the ordering. A minimum spanning tree (MST) is a subset of the edges of a connected, edge-weighted undirected graph that connects all the vertices together, without any cycles and with the minimum possible total edge weight. That is, it is a spanning tree whose sum of edge weights is as small as possible.

1.4. Our Main Results and Organization of the Paper

In Section 2 we start by designing a linear time in-place procedure to obtain linear bits of additional free space inside the offsets part of the adjacency array. Using this, we can already show an improved set of algorithms for (a strict superset of) problems that Chakraborty et al. [12] considered (for example, DFS, unordered BFS and MST), but this algorithms are still not optimal as they are at least polylog multiplicative factor away from linear running time. Towards obtaining optimal linear time in-place algorithms, we first provide an improved linear time in-place routine to obtain almost $n\lg n$ additional free bits of space inside the offsets part, which is what we use crucially along with other additional ideas to show the following main result of this paper in Section 3.

Theorem 1.1**.**

Using linear time in the in-place model, one can

1. (1)

traverse the vertices of any graph in (un)ordered BFS and DFS manner, 2. (2)

recognize bipartite graphs and compute connected components in undirected graphs, 3. (3)

report the vertices of a directed acyclic graph (DAG) in topologically sorted order, 4. (4)

obtain a maximum cardinality search ordering of any graph, 5. (5)

output an st-numbering of given biconnected graph, given two vertices $s$ and $t$, 6. (6)

perform a chain decomposition of any undirected graph, and 7. (7)

determine whether any given undirected graph $G$ is biconnected (and/or $2$-edge connected resp.) and if not, we can also compute and report all the cut vertices (bridges resp.) of $G$.

Also, given an undirected edge-weighted (where weights are bounded by some polynomial in $n$) graph $G$, we can find a minimum spanning tree (MST) of $G$ in $O(m\lg n)$ time in-place.

1.5. Techniques

All the results of our paper stem from the following very simple yet absolutely crucial observation: numbers in sorted order have less entropy than in any arbitrary order. More specifically, assuming we have $n$ numbers from a universe of size $m$, when these numbers are in any arbitrary order their binary entropy is $n\lg m$ but when they are in sorted order, binary entropy becomes $n\lg m-\Theta(n\lg n)$. This clearly indicates that we can exploit the sorted structure assumption to gain some additional space. Now, note that, without loss of any generality, by construction, the offsets part of the adjacency array $Z$ for any given graph $G$ is sorted. Thus, we can use the above mentioned idea in the offsets part of $Z$ to gain some free space which is what we use finally to design our optimal in-place graph algorithms. Towards this, we also have to handle several other key technical issues which we describe in respective sections in detail.

2. Saving Linear Bits and its Applications

As a warm up, in this section we start by showing how we can squeeze in linear sized free bits inside the offsets part of $Z$ while still being able to access any element inside the offsets part in $O(1)$ time, as well as returning to the original configuration of the offsets part of $Z$ before freeing linear bits. Towards this, we first reprove the following lemma, which is essentially same as [35, Lemma 5]. See Appendix A.2 for a proof.

Lemma 2.1**.**

Given a sorted list of $n$ integers from the universe $[0,m-1]$, it can be represented either simply as an array $A[1...n]$ with the integers in sorted order or as an array of $n$ integers, such that for some fixed constant $c>1$, the last $cn$ bits of this array are all zero. Moreover, there exists an in-place $O(n)$ time algorithm for switching between both these formats.

The above lemma alone is powerful enough to help us design in-place algorithms (albeit with sub-optimal time complexity as we will see shortly) for a variety of fundamental graph algorithms, thanks to the following theorems from [5, 11, 12].

Theorem 2.2**.**

In ROM, using $cn$ bits of space for some constant $c$, we can

1. (1)

traverse the vertices of any graph in unordered (ordered resp.) BFS manner in $O(m+n)$ ($O(m\lg^{2}n)$* resp.) time,* 2. (2)

recognize bipartite graphs and compute connected components in $O(m+n)$ time, 3. (3)

traverse the vertices of any graph in DFS order in $O(m\lg\lg n)$ time, 4. (4)

perform a topological sort of a DAG in $O(m\lg\lg n)$ time, 5. (5)

obtain a maximum cardinality search ordering of any graph in $O(m^{2}/n+m\lg n)$ time. 6. (6)

perform a chain decomposition of any undirected graph in $O(m\lg^{2}n\lg\lg n)$ time, 7. (7)

determine whether any given undirected graph $G$ is biconnected (and/or $2$-edge connected resp.) in $O(m\lg n\lg\lg n)$ time, and if not, in the same amount of time and space, we can compute and report all the cut vertices (bridges resp.) of $G$, 8. (8)

output an st-numbering of given biconnected graph in $O(m\lg^{2}n\lg\lg n)$ time, given two distinct vertices $s$ and $t$, and 9. (9)

compute a MST of a given edge-weighted undirected graph in $O(m\lg n)$ time.

Now armed with Theorem 2.2, we can easily obtain in-place algorithms for the above mentioned problems almost in a black box manner, albeit with sub-optimal running time (as for all these classical problems linear time algorithms are known [17, 46]) except for the unordered BFS problem and its applications (as mentioned in item $1$ and $2$) as they already admit linear time. More specifically, given the adjacency array representation (like in the $Z$ array) of the input graph $G$, we first apply Lemma 2.1 in the offsets part of $Z$ so that linear bits become free, and this is what we use to store/access the data structures required in Theorem 2.2, giving us the same running time bounds for these problems as stated in Theorem 2.2. Finally when the execution of these algorithms is finished, we again use Lemma 2.1 to restore the original configuration of the offsets part of $Z$, and thereby restoring the $Z$ array completely to its original state (note that the other parts of $Z$ are completely untouched as both Lemma 2.1 and Theorem 2.2 only worked on offsets part of $Z$). Also observe that we use only some constant number of variables (hence $O(\lg n)$ extra bits other than the input) throughout the entire execution of these algorithms. As a consequence, we obtain in-place algorithms for these problems. We summarize our discussion in the theorem below.

Theorem 2.3**.**

In the in-place model, one can

1. (1)

traverse the vertices of any graph in unordered (ordered resp.) BFS manner in $O(m+n)$ ($O(m\lg^{2}n)$* resp.) time,* 2. (2)

recognize bipartite graphs and compute connected components in $O(m+n)$ time, 3. (3)

traverse the vertices of any graph in DFS order in $O(m\lg\lg n)$ time, 4. (4)

perform a topological sort of a DAG in $O(m\lg\lg n)$ time, 5. (5)

obtain a maximum cardinality search ordering of any graph in $O(m^{2}/n+m\lg n)$ time, 6. (6)

perform a chain decomposition of any undirected graph in $O(m\lg^{2}n\lg\lg n)$ time, 7. (7)

determine whether any given undirected graph $G$ is biconnected (and/or $2$-edge connected resp.) in $O(m\lg n\lg\lg n)$ time, and if not, in the same amount of time and space, we can compute and report all the cut vertices (bridges resp.) of $G$, 8. (8)

output an st-numbering of given biconnected graph in $O(m\lg^{2}n\lg\lg n)$ time, given two distinct vertices $s$ and $t$, and 9. (9)

compute a MST of a given edge-weighted undirected graph in $O(m\lg n)$ time.

Observe that Theorem 2.3 already improves all the results of Chakraborty et al. [10] as they have shown in-place algorithms for a strict subset of problems (only item $1$, $3$ and $9$ above) considered in Theorem 2.3 using time $O(n\lg^{3}n)$. In the next section, however, we further improve the running time of Theorem 2.3 by providing improved version of Lemma 2.1.

3. Saving $n\lg n-2n$ Bits, and Its Applications

In what follows, we show how one can improve Lemma 2.1 so that almost $n\lg n$ bits become free to be used, and using this we will design optimal in-place algorithms for the above mentioned graph problems. Our main result can be described as follows:

Theorem 3.1**.**

Given a sorted list of $n$ integers from the universe $[0,m-1]$, it can be represented either simply as an array $A[1...n]$ with the integers in sorted order or as an array of $n$ integers, such that the last $n\lg n-2n$ bits of this array are all zero. Moreover, there exists an in-place $O(n)$ time algorithm for switching between both these formats.

Proof 3.2**.**

One can easily obtain the space bound mentioned in the second representation by applying the Elias-Fano encoding [25, 29] on the array $A$. But to implement this encoding in-place, we apply this encoding in two steps as described next.

We split the array $A$ into two subarrays of size $n/2$ each (assume, for simplicity, that $n$ is even) - call them $A_{1}$ and $A_{2}$. One can replace the most significant $\lg n$ bits of each of the elements in $A_{1}$ by a bit vector, say $B$, length $n+n/2$, using the Elias-Fano encoding. To store $B$ (of length $3n/2$), we first replace the most significant $3$ bits of each of the elements in $A_{2}$ by storing $8$ positions into the array $A_{2}$ (using Lemma 2.1, with $c=3$). We store the bit vector $B$ inside the most-significant $3$ bits of every element of $A_{2}$, and compact the remaining (least-significant $\lg m-\lg n$) bits of every element in $A_{1}$ into a consecutive chunk of $(n/2)\lg(m/n)$ bits in $A_{1}$, so that the first $(n/2)\lg n$ bits of $A_{1}$ is free (i.e., filled with all zeros). We now copy the bit vector $B$ into this free space, and restore the $3$ most significant bits of all the elements of $A_{2}$. We now replace the most-significant $\lg n$ bits of each element in $A_{2}$ by a bit vector $C$ of length $3n/2$, and store it inside free space in $A_{1}$ (here, we assume that $3n\leq(n/2)\lg n$), and compact the remaining (least-significant $\lg m-\lg n$) bits into a consecutive chunk of $(n/2)\lg(m/n)$ bits in $A_{2}$. Finally, we copy all the lower order bits (of total length $n\lg(m/n)$ bits) into a single chunk, and also merge the two bit vectors of length $3n/2$ each into a single bit vector of length $2n$. Thus the array $A$ is replaced by a total of $n\lg(m/n)+2n$ bits, giving a free space of $n\lg n-2n$ bits. These steps can be essentially performed in reverse order to restore the original representation from the second representation. To support the operation of accessing the $i$-th element of $A$ in $O(1)$ time, we can store an additional $o(n)$-bit auxiliary structure that support the rank and select operations [16, 40] on the $2n$ bit sequence, which can then be used to access the most-significant $\lg n$ bits of any element in $O(1)$ time. The remaining $\lg m-\lg n$ bits can be simply read from the array of values stored in the second representation. See Figure 2 in Appendix A.1 for a visual description of the final outcome of application of this theorem.

In what follows, we show how one can use Theorem 3.1 for solving the graph problems mentioned before. Before giving specific details, we would like to sketch the general pattern for designing optimal in-place algorithms for some of these graph problems. Given the adjacency array presentation (as in $Z$) of the input graph $G$, we now first apply Theorem 3.1 on the offsets part of $Z$ to make $n\lg n-2n$ bits free. Now the classical linear time algorithms [17, 28, 46, 47, 48, 50] for these problems typically take $cn\lg n+dn$ bits where both the constants $c$ and $d$ are at most $2$. Hence, our idea is to run these algorithms as it is but in some constant number of phases. More specifically, we store only, say $n/3$ vertices, explicitly at any point of time during the execution of these algorithms, and when these vertices are taken care of by the respective algorithms, we refresh the data structures by initiating it with a new set of $n/3$ vertices and proceed again till we exhaust all the vertices, thus, the entire algorithm would finish in three phases ultimately. Now the exact details of refreshing the data structure with a new set of vertices and start the algorithm again where it left off depends on specific problems. This idea would work for most of the algorithms that we discuss in this paper except a few important ones. More specifically, a few of the algorithms for those graph problems are two (or more) pass algorithms, i.e., in the first pass it computes some function which is what used in the second pass to solve the problem finally, for example, chain decomposition, biconnectivity etc. For these kinds of algorithms, it seems hard to make them work using the previously described constant phase algorithmic idea. Thus, we handle them differently by first proving some related lemmata which might be of independent interest, and then use these lemmata to design in-place algorithms for these graph problems. We discuss these after giving proofs for the algorithms which we can handle in constant phases only. In what follows we provide the proofs of linear time in-place algorithms for DFS and its applications, especially chain decompsotion, biconnecitivity, $2$-edge connectivity, and also develop/prove the necessary ideas for these algorithms. The missing parts of Theorem 1.1 are proved in Appendix A.4 due to lack of space.

The classical implementation of DFS (see for example, Cormen et al. [17]) uses three colors and a stack to traverse the whole graph. More specifically, every vertex $v$ is white initially while it has not been discovered yet, becomes grey when DFS discovers $v$ for the first time and pushes on the stack, and is colored black when it is finished i.e., all its neighbors have been explored completely, and it leaves the stack. The algorithm maintains a color array $C$ of length $O(n)$ bits that stores the color of each vertex at any point in the algorithm, along with a stack (which could grow to $O(n\lg n)$ bits) for storing all the grey vertices at any point during the execution. Our idea is to run essentially the same DFS algorithm but we limit the stack size so that it contains at most $n/2$ latest grey vertices all the time. More specifically, whenever the stack grows to have more than $n/2$ vertices, we delete the bottom most vertex from the stack so that above invariant is always maintained along with storing the last such vertex to be deleted in order to enforce the invariant. At some point during the execution of the algorithm, when we arrive at a vertex $v$ such that none of $v$’s neighbors are white, then we color the vertex $v$ as black, and we pop it from the stack. If the stack is still non-empty, then the parent of $v$ (in the DFS tree) would be at the top of the stack, and we continue the DFS from this vertex. On the other hand, if the stack becomes empty after removing $v$, we need to reconstruct it to the state such that it holds the last $n/2$ grey vertices after all the pops done so far. We refer to this phase of the algorithm as reconstruction step. For this, using ideas from [3], we basically repeat the same algorithm but with one twist which also enables us now to skip some of the vertices during this reconstruction phase. In detail, we again start with an empty stack, insert the root $s$ first and scan its adjacency list from the first entry to skip all the black vertices and insert into the stack the leftmost grey vertex. Then the repeat the same for this newly inserted vertex into the stack until we reconstruct the last $n/2$ grey vertices. As we have stored the last vertex to be deleted for maintaining the invariant true, we know when to stop this reconstruction procedure. It is not hard to see that this procedure correctly reconstructs the latest set of grey vertices in the stack. We continue this process until all the vertices become black. Moreover, this algorithm runs in $O(m+n)$ time as it involves two phases each taking linear time in the worst case, and uses at most $(n\lg n)/2+n\lg 3$ bits which fits in our budget of free space in the offsets part of the adjacency array. This completes the description of the linear time in-place DFS algorithm.

Before providing the algorithms for other problems, we need a few additional ideas which we will describe next. In the following theorem, we are interested in dynamically maintaining the degree sequence of all vertices that belong to a spanning subgraph of the original graph. More specifically, given a graph $G=(V,E)$, we want to run some algorithm on $G$ for constructing a sparse spanning subgraph $G^{\prime}=(V,E^{\prime})$ (which is a spanning subgraph of $G$ i.e., $E^{\prime}\subseteq E$ and $|E^{\prime}|=O(V)$) of $G$, and we are interested in dynamically maintaining the degree of all the vertices $v$ in $G^{\prime}$ i.e., degree of a vertex $v$ in $G^{\prime}$ is defined as the number of neighbors $u$ such that the edge $(v,u)$ belongs to $G^{\prime}$. Thus, degree of a vertex $v$ in $G^{\prime}$ may not be same as degree of $v$ in $G$. Also note that, by the notion of dynamic, we mean that the algorithm starts with an empty graph and gradually add edges to it before finally culminating with a sparse spanning subgraph, thus during the execution of this algorithm degrees of the individual vertices are changing, and it is this dynamically changing degrees that we want to efficiently maintain. We refer to this as the dynamic maintenance of degree sequence phase. Towards this goal, we prove the following general theorem.

Theorem 3.3**.**

Given a graph $G$ with $n$ vertices and $m$ edges, let $G^{\prime}$ be a spanning subgraph of $G$ with $m^{\prime}$ edges, and also let $d^{\prime}=m^{\prime}/n$ be the average degree of $G^{\prime}$. Then, we can construct the dynamically created degree sequence for the vertices of $G^{\prime}$ in $O(m+n)$ time using $O(n(\lg d^{\prime}+\lg\lg n))$ bits of construction space. Moreover, the final degree sequence can be stored using $O(n\lg d^{\prime})$ bits such that degree of any vertex can be returned in $O(1)$ time.

Proof 3.4**.**

We divide the vertices into $n/\lg n$ groups of $\lg n$ vertices each. For each group, we allocate a block of $\lg n(\lg d^{\prime}+\lg\lg n)$ ($\leq\lg^{2}n$) bits initially (uniformly for all the vertices in the block), to store their degrees. We also maintain another parallel bit vector for each block that simply stores the delimiters for each vertex’s degree (i.e., a 1 bit to indicate the last bit corresponding to each vertex’s degree, and 0 everywhere else). To access the degree of the $i$-th vertex in a block, we first find the positions of the $i-1$-th and the $i$-th 1 bits in the corresponding delimiter sequence, and read the bits between these two positions in the block. To perform this efficiently during the construction, we maintain an auxiliary structure that supports select operation in $O(1)$ time [16, 40]. At any point, the representation of each block and delimiter sequence consists of an integral number of words, and these representations are maintained as a collection of “extendible arrays” using the structure of [43, Lemma 1].

At any time, a vertex has some number of bits allocated to store its degree. If the degree of the vertex can be updated in-place, then we first access the position where the degree of the vertex is stored, using the select data structure stored for the corresponding delimiter sequence, and update the degree of the node stored within the block. Otherwise, we first note that at least $\lg n$ increments have been performed to some vertex within the block (since each vertex has a ‘slack’ of $\lg\lg n$ bits at the beginning of the latest re-construction of the block). Now, we spend $O(\lg n)$ time to re-construct the block (and also the corresponding delimiter sequence with its select structure) so that the degree of each vertex $v$ in the block is stored $\lceil{\lg d_{v}}\rceil+\lg\lg n$ bits, where $d_{v}$ is the current degree of $v$. This $\lg n$ construction time can be amortized over the $\lg n$ increments performed on the block before its re-construction, incurring an $O(1)$ amortized cost per increment. Once we construct the degree sequence for the entire subgraph $G^{\prime}$, we can scan all the blocks, and compact the degree sequence so that it occupies $O(n\lg d^{\prime})$ bits. The space usage during the construction is bounded by $O(n(\lg d^{\prime}+\lg\lg n))$ bits of space. Note that, the above task can be performed while executing the linear time DFS algorithm described before, and this completes the proof.

Corollary 3.5**.**

When $G^{\prime}$ is the DFS tree of $G$, then we can store the dynamically created degree sequence of $G^{\prime}$, whose size is bounded by $2n$ bits, by running a $O(m+n)$ time DFS procedure while using $O(n\lg\lg n)$ bits of space during construction such that the degree of any vertex in $G^{\prime}$ can be accessed in $O(1)$ time.

For the following discussion, assume that we are working with connected undirected graphs only, and given this, now we are going to describe the setting up parent phase. More specifically, while performing DFS, suppose we visit the vertex $u$ for the first time from the vertex $v$ (hence $v$ becomes the parent of $u$ in the DFS tree), at that point we perform one or more swaps in the portion of the adjacency array $Z$ where the neighbors of $u$ are located so that the vertex $v$ becomes the first neighbor of $u$ now. If the initial configuration of $Z$ already satisfies this property in $u$’s neighborhood, we don’t need to do anything else. We repeat this procedure for every vertex $v\in V$ so that when DFS ends, the first neighbor of every vertex $v$ (except the root vertex) is its parent in the DFS tree. Note that we can perform this step of setting up parent in the first location of every neighborhood list of every vertex alongside performing the linear time DFS algorithm of Theorem 1.1. Thus, we obtain the following,

Lemma 3.6**.**

There exists a linear time in-place algorithm for performing the setting up parent procedure for every vertex of $G$.

Note that, by choosing appropriate parameters, we can actually perform the dynamic maintenance of degree sequence and the setting up parent phase together while running the linear time in-place DFS algorithm of Theorem 1.1 in any graph $G$. More specifically, suppose we choose to run the linear time in-place DFS algorithm of Theorem 1.1 coupled with the setting up parent procedure (to implement Lemma 3.6) by storing $n/2$ vertices (thus taking $n\lg n/2$ bits) in the free space of the offsets part of $Z$, thus, leaving roughly $(n\lg n/2-2n)$ bits of space still free, which can be used to construct and store the degree sequence of all the vertices in the DFS tree (to implement corollary 3.5) while running the same linear time in-place DFS algorithm of Theorem 1.1. By degree of a vertex $v$ in the DFS tree $T$, we mean the number of children $v$ has in $T$, and it is this number that gets stored using the algorithm of Corollary 3.5. Hence, at the end of this linear time in-place procedure, we have the following invariant: (a) the first neighbor of every vertex (except the root) is its parent in the DFS tree, and (b) the offsets part of $Z$ contains the degree sequence of every vertex $v$ in the DFS tree, and this occupies at most $2n$ bits.

Armed with the above algorithm, we are going to explain next the implicitly representing the search tree phase. The goal of this phase is to rearrange the neighbors of any vertex $v$ in such a way such that the first neighbor of $v$ becomes its parent in the DFS tree (except for the root vertex), this is followed by all of $v$’s children in the DFS tree (if any) one by one, finally all the non-child neighbors. Thanks to the setting up parent phase, we can implement the implicitly representing the search tree phase in linear time overall by doing a reverse search. More specifically, for every non-root vertex $v$, we start by scanning $v$’s list from the second neighbor onward (as first neighbor is its parent), and for each one of them, say $u$, we go to the first location of $u$’s neighbor list to check if $v$ is $u$’s parent if so, we move $u$ in $v$’s list closer to $v$’s parent (i.e., towards the beginning of $v$’s list) by swapping, and repeat this procedure for all the neighbors of $v$’s so that at the end all the children of $v$ are clustered together followed by $v$’s parent. The root vertex can be handled similarly, but we need to start the scanning procedure from the first neighbor itself as it doesn’t have any parent. Hence, we spend time proportional to its degree at every vertex, and obtain the following.

Lemma 3.7**.**

There exists a linear time in-place algorithm for implicitly representing the search tree of $G$.

Thus, from now on we can assume that the neighbor list of every vertex is represented in the search tree format implicitly. We choose to call it so as, note that, given in this format, it is very convenient to answer the following queries for any given vertex $v$ in the DFS tree $T$: (a) return the parent of $v$ in $T$ in $O(1)$ time, (b) return the number of children $v$ has in $T$ in $O(1)$ time (from the dynamically maintained degree sequence), and finally, (c) enumerate all the children of $v$ one by one optimally in time proportional to its number of children. Not only this, observe that we can still perform the DFS traversal of $G$ optimally in linear-time using essentially the same algorithm of Theorem 1.1 given this representation. We can even slightly optimize this DFS algorithm by stop scanning the neighbor list of any vertex $v$ as soon as we encounter its last child $u$ in the DFS tree (can be derived from the dynamically maintained degree sequence) as neighbors after $u$ will not be of significance in performing the DFS traversal of $G$. Hence, we obtain the following.

Lemma 3.8**.**

There exists a linear time in-place algorithm for performing the DFS traversal of a given graph $G$ using the implicit search tree representation of $G$.

With the lemma above, we almost complete the description of all the ideas required to design linear time in-place algorithms for the last two items of Theorem 1.1. In what follows, we describe the necessary graph theoretic background for explaining our algorithms.

Schmidt [45] introduced a decomposition of the input undirected graph that partitions the edge set of the graph into cycles and paths, called chains, and used this to design an algorithm to find cut vertices and biconnected components [46] and also to test 3-connectivity [45] among others. In what follows, we discuss briefly the decomposition algorithm, and state his main result. The algorithm first performs a DFS on $G$. Let $r$ be the root of the DFS tree $T$ of $G$. DFS assigns an index to every vertex $v$, namely, the time vertex $v$ is discovered for the first time during DFS – call it the depth-first-index of $v$ (DFI(v)). Imagine that the back edges are directed away from $r$ and the tree edges are directed towards $r$. The algorithm decomposes the graph into a set of paths and cycles called chains as follows. See Figure 3 in Appendix A.3 for an example. First we mark all the vertices as unvisited. Then we visit every vertex starting at $r$ in the increasing order of DFI (i.e., in DFS order), and do the following. For every back edge $e$ that originates at $v$, we traverse a directed cycle or a path. This begins with $v$ and the back edge $e$ and proceeds along the tree towards the root and stops at the first visited vertex or the root. During this step, we mark every encountered vertex as visited. This forms the first chain. Then we proceed with the next back edge at $v$, if any, or move towards the next vertex in the increasing DFI order and continue the process. Let $D$ be the collection of all such cycles and paths. Notice that the cardinality of this set is exactly the same as the number of back edges in the DFS tree as each back edge contributes to a cycle or a path. Also, as initially every vertex is unvisited, the first chain would be a cycle as it would end in the starting vertex. Using this, Schmidt proved the following.

Theorem 3.9** ([46]).**

Let $D$ be a chain decomposition of a connected undirected graph $G=(V,E)$. Then $G$ is 2-edge-connected if and only if the chains in $D$ partition $E$. Also, $G$ is biconnected if and only if $\delta(G)\geq 2$ (where $\delta(G)$ denotes the minimum degree of $G$) and $D_{1}$ is the only cycle in the set $D$ where $D_{1}$ is the first chain in the decomposition. An edge $e$ in $G$ is a bridge if and only if $e$ is not contained in any chain in $D$. A vertex $v$ in $G$ is a cut vertex if and only if $v$ is the first vertex of a cycle in $D\setminus D_{1}$.

In what follows, we use the linear time in-place DFS algorithm of Lemma 3.8 to perform the tests in Theorem 3.9. More specifically, using the linear time DFS algorithm of Lemma 3.8 along with the help of the implicit search tree representation, we can visit every vertex, starting at the root $r$ of the DFS tree, in increasing order of DFI, and enumerate (or traverse through) all the non-tree (back) edges of the graph as required in Schimdt’s algorithm as follows: for each node $v$ in DFI order, we can retrieve the number of children, say $t$, $v$ has in the DFS tree from the stored degree sequence in $O(1)$ time, then if we directly access the $(t+2)$-th neighbor, say $u$, of $v$, we are guaranteed that the edge $(v,u)$ must be a back edge, thanks to the implicit search tree representation. Moreover all the neighbors starting from the $(t+2)$-th location till the end of $v$’s neighbor list constitute back edges that emanate from $v$. Now we maintain a bit array, visited, of size $n$ (in the free space of the offsets part), corresponding to the $n$ vertices, initialized to all zeros meaning all the vertices are unvisited at the beginning. We use the visited array to mark vertices visited during the chain decomposition. When a new back edge is visited for the first time, the algorithm traverses the path starting with the back edge followed by a sequence of tree edges (towards the root) until it encounters a marked vertex, and also marks all the vertices on this path. Note that we can achieve this by repeatedly finding the parent using the implicit search tree representation, i.e., suppose $(v,u)$ is a back edge (which is discovered from $v$’s neighbor list), then we traverse to $u$’s neighbor list to find its parent, say $w$, followed by finding $w$’s parent and so on till we encounter a marked vertex. By checking whether the vertices are marked or not, we can also distinguish whether an edge is encountered for the first time or has already been processed. Note that this procedure constructs the chains on the fly. To check whether an edge is a bridge or not, we first note that only the tree edges can be bridges (back edges always form a cycle along with some tree edges). Also, from Theorem 3.9, it follows that any (tree) edge that is not covered in the chain decomposition algorithm is a bridge. Thus, to report these, we maintain a bitvector $M$ of length $n$, corresponding to the $n$ vertices, initialized to all zeros. Whenever a tree edge $(u,v)$ is traversed during the chain decomposition algorithm, if $v$ is the child of $u$, then we mark the child node $v$ in the bit vector $M$. After reporting all the chains, we scan the bitvector $M$ to find all unmarked vertices $v$ and output the edges $(u,v)$, where $u$ is the parent of $v$, as bridges. If there are no bridges found in this process, then $G$ is $2$-edge connected. To check whether a vertex is a cut vertex (using the characterization in Theorem 3.9), we keep track the starting vertex of the current chain (except for the first chain, which is a cycle), that is being traversed, and report that vertex as a cut vertex if the current chain is a cycle. If there are no cut vertices found in this process then $G$ is biconnected. Otherwise, we keep one more array of size $n$ bits to mark which vertices are cut vertices. This completes the description of linear time in-place algorithms for performing chain decomposition, checking biconnectivity and/or $2$-edge connecitivity, and finding cut vertices and bridges using Schmidt’s algorithm.

4. Conclusion

In this paper, we designed linear time in-place algorithms for a variety of graph problems. As a consequence, many interesting and contrasting observations follow. For example, for directed st-reachability, the most space efficient polynomial time algorithm [7] in ROM uses $n/2^{\Theta(\sqrt{\lg n})}$ bits. In sharp contrast, we obtain optimal linear time using logarithmic extra space algorithms for this problem as a simple corollary of both BFS and DFS. Thus, in terms of workspace this is exponentially better than the best known polynomial time algorithm [7] in ROM. This provided us with one of the main motivations for designing algorithms in the in-place model. A somewhat incomparable result obtained by Buhrman et al. [9, 36] where they gave an algorithm for directed st-reachability on catalytic Turing machines in space $O(\lg n)$ with catalytic space $O(n^{2}\lg n)$ and time $O(n^{9})$. Finally, we conclude by mentioning that we barely scratched the surface of designing in-place graph algorithms with plenty of more to be studied in this model in future. For example, can we design linear time in-place algorithms for testing planarity of a graph? Can we compute the max-flow/min-cut in-place? Can we compute shortest paths between any two vertices of a given graph in-place? We leave these problems as our future directions of study.

Appendix A Appendix

We provide in this section all the missing proofs and diagrams. The corresponding theorems are repeated for the reader’s convenience.

A.1. Configuration of Adjacency Array Before and After Freeing Space

A.2. Proof of Lemma 2.1

Lemma 2.1 (Restated) *Given a sorted list of $n$ integers from the universe $[0,m-1]$, it can be represented either simply as an array $A[1...n]$ with the integers in sorted order or as an array of $n$ integers, such that for some fixed constant $c>1$, the last $cn$ bits of this array are all zero. Moreover, there exists an in-place $O(n)$ time algorithm for switching between both these formats. *

Proof A.1**.**

We first note that the most significant $c$ bits of all the numbers in any subarray of $A$ can be retrived by storing $2^{c}-1$ positions into the subarray, since they form a non-decreasing sequence (of length $n$) over the range $[0,2^{c}-1]$. Thus if we store these $2^{c}$ positions in the working space, then we can compact the remaining $\lg m-c$ bits of all the elements of the array so that they occupy the first $n(\lg m-c)$ bits of the array $A$, freeing the last $cn$ bits. One can decrease the working space usage by performing this in two stages: in the first stage, we can create $n$ bits of empty space by storing one position in the working space (i.e., with $c=1$); then in the next stage, we can store the remaining $2^{c}-2$ positions in those linear bits, and create further $(c-1)n$ bits of empty space. To access the $i$-th element of $A$ in the second representation, we can find the most significant $c$ bits of $A[i]$ by counting the number of positions that are less than $i$ from the $2^{c}-1$ positions stored. The least significant $\lg m-c$ bits can be simply read from the array stored in the second representation. To restore the first representation from the second, one can obtain the most significant $c$ bits of each element from the $2^{c}$ positions stored, and read the remaining bits from the array.

A.3. An Illustration of Chain Decomposition Algorithm

A.4. Missing Proofs of Theorem 1.1

Theorem 1.1 (Restated partly) Using linear time in the in-place model, one can

1. (1)

traverse the vertices of any graph in ordered BFS manner , 2. (2)

recognize bipartite graphs and compute connected components in undirected graphs, 3. (3)

report the vertices of a directed acyclic graph (DAG) in topologically sorted order, 4. (4)

obtain a maximum cardinality search ordering of any graph, 5. (5)

*output an st-numbering of given biconnected graph, given two vertices $s$ and $t$, *

*Also, given an undirected edge-weighted (where weights are bounded by some polynomial in $n$) graph $G$, we can find a minimum spanning tree (MST) of $G$ in $O(m\lg n)$ time in-place. *

Proof A.2**.**

We start with the ordered BFS problem for which the classical linear time algorithm starts by coloring all vertices white i.e., unvisited. Then it grows the search starting at the root vertex, say $s$, making it grey (i.e., visited but not completely explored) and adding it to a queue. Finally the algorithm repeatedly removes the first element of the queue, and adds all its white neighbors at the end of the queue (coloring them grey), coloring the element black (i.e., completely explored) after removing it from the queue. As the queue can store up to $O(n)$ elements, the space for the queue can be $O(n\lg n)$ bits. Towards the efficient in-place implementation of this algorithm, we also maintain (in a slightly different format) all the colors in an array, say $C$, along with maintaining a queue. First observe that elements in the queue are only from two consecutive levels of the BFS tree, and the traditional algorithm colors all these vertices grey initially. We refine this further and color them separately as $grey_{1}$ and $grey_{2}$. As a consequence, now the algorithm repeatedly removes the first element of the queue (say having color $grey_{1}$), and adds all its white neighbors at the end of the queue (coloring them $grey_{2}$), coloring the element black after removing it from the queue, and vice versa. Note that, if the combined size of the two consecutive levels of the BFS tree (i.e., $grey_{1}$ and $grey_{2}$ vertices) remains bounded by $n/2$ throughout the entire BFS algorithm, then we get immediately linear time in-place BFS algorithm as we can store these vertices (along with the color array) in the free space of the offsets part of the adjacency array. If not, then one of the levels, say $grey_{1}$ level without loss of generality and denote it by level $L$, has more than $n/2$ vertices, then all the other levels combined must have less than $n/2$ vertices. In particular, the level $(L-1)$ and $(L+1)$ has less than $n/2$ vertices. As we cannot store the level $L$ explicitly in the free space at once, our idea is to generate the level $L$ from the level $(L-1)$ (which we can store explicitly) on the fly. More specifically, assuming we have the level $(L-1)$ stored explicitly, we repeatedly expand (till we exhaust) each vertices from this level and generate the vertices of level $L$ but instead of storing them in the queue, we just change the color of these vertices in the color array. Now in order to generate the vertices of level $(L+1)$, we need to expand the vertices of level $L$ in the correct order but we did not store them in the array, thus, we again repeat the expansion of vertices from level $(L-1)$ one by one to generate the vertices of level $L$ in order and at that time only, we process them to generate their neighbors which belong to level $(L+1)$ along with changing their colors in $C$ array, and storing them in a queue (as we can afford to store these) for future exploration. Note that this phenomenon happens at most once during the entire execution of the BFS algorithm. Now, it is easy to see that this procedure correctly traverses the input graph $G$ in the ordered BFS manner using $O(m+n)$ time in-place. Using this linear time in-place BFS algorithm, it is straightforward to obtain the recognition algorithm for bipartite graphs, and compute the connected components in undirected graphs as all of these are simple applications of BFS. Hence we also obtain linear time in-place algorithms for these problems.

One of the standard algorithms for computing topological sort [17] works by simply reporting the vertices of a DFS traversal of a given directed acyclic graph in reverse order. We can easily implement this in-place in linear time by running our DFS algorithm in two phases. More specifically, in the first phase, we run the DFS algorithm completely to generate/store the last $n/2$ vertices in the DFS traversal order, and then report them in reverse order. This is followed by running the DFS algorithm one more time but stopping just when we obtain the other $n/2$ vertices, then we reverse the order of this vertices and report. This completes the description of generating the vertices in topologically sorted order of an input directed acyclic graph in-place in linear time.

We start by briefly recalling the MCS algorithm and its implementation as provided in [12, 50]. The output of the MCS algorithm is a numbering of the vertices from $1$ to $n$. Now assume that every vertex is unnumbered at the beginning of the algorithm. Then, during the execution, at each iteration of the algorithm, an unnumbered vertex that is adjacent to the most number of numbered vertices is chosen (breaking the ties arbitrarily), and is numbered with the next available label. To implement this strategy, the MCS algorithm (as described by [12] by slightly improving the classical implementation of [50]) maintains an array of sets $set[i]$ for $0\leq i\leq n-1$ where $set[i]$ stores all unnumbered vertices adjacent to exactly $i$ numbered vertices. So, at the beginning all the vertices belong to $set[0]$. The algorithm also maintains the largest index $j$ such that $set[j]$ is non-empty. To implement an iteration of the MCS algorithm, we remove a vertex $v$ from $set[j]$ and number it. For each unnumbered vertex $w$ adjacent to $v$, $w$ is moved from the set containing it, say $set[i]$, to $set[i+1]$. If there is a new entry in $set[j+1]$, we set the largest index to $j+1$, and repeat the same. Otherwise when $set[j]$ becomes empty, we repeatedly decrement $j$ till a non-empty set is found and in this set we repeat the same procedure. In order to delete easily, we implement each set as a doubly-linked list. In addition, for every vertex $v$, we also need to store a pair $(i,j)$ if the vertex $v$ belongs to the list $set[i]$ and $j$ is the pointer to $v$’s location inside $set[i]$ to get linear time overall. This completes the description of the implementation level details of MCS. To implement this algorithm in-place using linear time, we essentially run the same algorithm but in four phases. More specifically, we use the above mentioned data structures for storing the top most $n/4$ vertices (in terms of the number of numbered neighbors) at any point during execution along with storing their $(i,j)$ pairs. We also store in a bitvector which vertices have been numbered by the algorithm so far. Then, after we exhaust these vertices, we spend a linear time by scanning the complete adjacency array to determine the next set of top most $n/4$ vertices to initiate these data structures, after which the algorithm starts working where it left off. It can be seen that we can afford to store these information in our free space to essentially ensure linear overall time for the execution of MCS.

For the st-numbering problem, Chakraborty et al. [11] modified the classical algorithm of Tarjan [49] and showed that using $O(n)$ bits of space, st-numbering of any given biconnected graph $G$ and two distinct vertices $s$ and $t$, can be performed in $O(m\lg^{2}n\lg\lg n)$ time. This algorithm essentially runs in $O(\lg n)$ phases and in each phase the algorithm performs a DFS and some other related work in time $O(m\lg n\lg\lg n)$ while storing $O(n/\lg n)$ vertices in the working space (as they had only $O(n)$ bits available). In order to obtain linear time in-place algorithm for the st-numbering problem, we can simply run the same algorithm in some constant number, say $k$, of phases along with storing $O(n/k)$ vertices explicitly and in each of those phases, we can run our linear time in-place DFS algorithm of Theorem 1.1 to perform the tasks needed in their algorithm [11], hence giving us the desired result.

Finally, for the minimum spanning tree (MST) problem, we can essentially run the classical Prim’s algorithm [17] using binomial heap in some constant number of phases (like the previous algorithms) to achieve $O(m\lg n)$ running time. We omit the simple details here.