Depth-First Search Using $$O(n)$$ Bits

Asano, Tomohiko; Izumi, Taisuke; Kiyomi, Masashi; Konagaya, Matsuo; Ono, Hiroyuki; Otachi, Yota; Schweitzer, Pascal; Tarui, Jun; Uehara, Ryuhei

doi:10.1007/978-3-319-13075-0_44

Cited by 31 publications

(42 citation statements)

References 15 publications

Supporting

Mentioning

Contrasting

Unclassified

Order By: Relevance

“…Asano et al [3] showed that Depth First Search (DFS) in a directed or an undirected graph can be performed in O(m lg n) time and O(n) bits of space. Elmasry et al [37] improved the time to O(m lg lg n) still using O(n) bits of space.…”

Section: Our Results and Organization Of The Papermentioning

confidence: 99%

See 1 more Smart Citation

Biconnectivity, st-numbering and other applications of DFS using O(n) bits

Chakraborty

Raman

Satti

2017

Journal of Computer and System Sciences

View full text Add to dashboard Cite

We consider space efficient implementations of some classical applications of DFS including the problem of testing biconnectivity and 2-edge connectivity, finding cut vertices and cut edges, computing chain decomposition and st-numbering of a given undirected graph G on n vertices and m edges. Classical algorithms for them typically use DFS and some Ω(lg n) bits 1 of information at each vertex. Building on a recent O(n)-bits implementation of DFS due to Elmasry et al. (STACS 2015) we provide O(n)-bit implementations for all these applications of DFS. Our algorithms take O(m lg c n lg lg n) time for some small constant c (where c ≤ 2). Central to our implementation is a succinct representation of the DFS tree and a space efficient partitioning of the DFS tree into connected subtrees, which maybe of independent interest for designing other space efficient graph algorithms.

show abstract

Section: Our Results and Organization Of The Papermentioning

confidence: 99%

“…As is standard in the area of space-efficient graph algorithms [3,6,5,37], we assume that the input graph is given in a read-only memory (and so cannot be modified). If an algorithm must do some outputting, this is done on a separate write-only memory.…”

Section: Model Of Computationmentioning

confidence: 99%

Biconnectivity, st-numbering and other applications of DFS using O(n) bits

Chakraborty

Raman

Satti

2017

Journal of Computer and System Sciences

View full text Add to dashboard Cite

show abstract

“…In what follows, we illustrate a bit more on the inner working details of BDS j with the help of an example. Following the convention, as in the recent papers [1,2], here also in BDS j we output the vertices as and when they are expanded (note that, if reporting in any other order is required, it can be done so with straighforward modification in our algorithms). Hence the root will be output at the very first step, followed by its rightmost child and so on.…”

Section: Breadth-depth Search Of Jiangmentioning

confidence: 99%

“…As this can happen only for O(lg n) rounds, and since in each round we might spend O(m) time to scan the adjacency list and insert correct vertices into the stack, overall this procedure takes O(m lg n) time. We conclude this section by mentioning that a similar kind of idea was used in [1] to provide space efficient DFS implementation, but we emphasize that ours algorithm is markedly different than [1] from the point of view of introducing delayed insertion of vertices into the stack, and thus removing the adaptivity from the stack, both the features not present in DFS. In what follows, we describe an improved algorithm generalizing the ideas developed in this section.…”

Section: Using O(n) Bits and O(m Lg N) Timementioning

confidence: 99%

Space Efficient Algorithms for Breadth-Depth Search

Chakraborty

Mukherjee

Satti

2019

Fundamentals of Computation Theory

View full text Add to dashboard Cite

Continuing the recent trend, in this article we design several space-efficient algorithms for two well-known graph search methods. Both these search methods share the same name breadth-depth search (henceforth BDS), although they work entirely in different fashion. The classical implementation for these graph search methods takes O(m + n) time and O(n lg n) bits of space in the standard word RAM model (with word size being Θ(lg n) bits), where m and n denotes the number of edges and vertices of the input graph respectively. Our goal here is to beat the space bound of the classical implementations, and design o(n lg n) space algorithms for these search methods by paying little to no penalty in the running time. Note that our space bounds (i.e., with o(n lg n) bits of space) do not even allow us to explicitly store the required information to implement the classical algorithms, yet our algorithms visits and reports all the vertices of the input graph in correct order.

show abstract

“…Let us also use the common picture according to which every vertex is initially white, becomes gray when it is discovered and pushed on the stack, and turns black when all its incident (out)edges have been explored and it leaves the stack. The study of space-efficient DFS was initiated by Asano et al [2]. Besides a number of DFS algorithms whose running times were characterized only as polynomial in n or worse, they described an algorithm that uses O(m log n) time and O(n) bits and another algorithm that uses O(nm) time and at most (log 3 + ǫ)n bits, for arbitrary fixed ǫ > 0, where "log", here and in the remainder of the paper, denotes the binary logarithm function log 2 .…”

Section: Introduction and Related Workmentioning

confidence: 99%

Space-Efficient DFS and Applications to Connectivity Problems: Simpler, Leaner, Faster

Hagerup

2019

Algorithmica

View full text Add to dashboard Cite

The problem of space-efficient depth-first search (DFS) is reconsidered. A particularly simple and fast algorithm is presented that, on a directed or undirected input graph G = (V, E) with n vertices and m edges, carries out a DFS in O(n + m) timeA slightly more complicated variant of the algorithm works in the same time with at most n + (4/5)m + O(log n) bits. It is also shown that a DFS can be carried out in a graph with n vertices and m edges in O(n + m log * n) time with O(n) bits or in O(n + m) time with either O(n log log(4 + m/n)) bits or, for arbitrary integer k ≥ 1, O(n log (k) n) bits. These results among them subsume or improve most earlier results on space-efficient DFS. Some of the new time and space bounds are shown to extend to applications of DFS such as the computation of cut vertices, bridges, biconnected components and 2-edge-connected components in undirected graphs.

show abstract

Depth-First Search Using $$O(n)$$ Bits

Cited by 31 publications

References 15 publications

Biconnectivity, st-numbering and other applications of DFS using O(n) bits

Biconnectivity, st-numbering and other applications of DFS using O(n) bits

Space Efficient Algorithms for Breadth-Depth Search

Space-Efficient DFS and Applications to Connectivity Problems: Simpler, Leaner, Faster

Contact Info

Product

Resources

About