#
Space-Efficient Fully Dynamic DFS in Undirected Graphs ^{†}

^{*}

^{†}

^{‡}

## Abstract

**:**

## 1. Introduction

#### 1.1. Existing Results

#### 1.2. Our Results

#### 1.3. Applications

## 2. Preliminaries

**Bit Vectors.**Let $B[1\dots l]$ be a 0,1-sequence of length l, and consider two queries on B: for $c=0,1$, ${\mathtt{rank}}_{c}(i,B)$ returns the number of occurrences of c in $B[1\dots i]$, and ${\mathtt{select}}_{c}(i,B)$ returns the position of the i-th occurrence of c in B if exists or ∅ otherwise. Then there exists a data structure such that

`rank`and

`select`queries for $c=0,1$ can both be answered in $O\left(1\right)$ time and the required space is $l+O(l\mathrm{log}\mathrm{log}l/\mathrm{log}l)=l+o\left(l\right)$ bits [15,16]. Moreover, the space can be reduced to $l{H}_{0}\left(B\right)+o\left(l\right)$ bits while keeping $O\left(1\right)$ query time [17], where ${H}_{0}\left(B\right)\le 1$ is the zeroth-order empirical entropy of B. When 1 occurs k times in B, $l{H}_{0}\left(B\right)=k\mathrm{log}\frac{l}{k}+(l-k)\mathrm{log}\frac{l}{l-k}\le k\mathrm{log}\frac{el}{k}$.

**Wavelet Trees.**Let $S[1\dots l]$ be an integer sequence of symbols $[0,\sigma -1]$. A wavelet tree [12] for S is a complete binary tree with $\sigma $ leaves and $\sigma -1$ internal nodes, each internal node of which has a bit vector [15,16]. Each node v corresponds to an interval of symbols $[{l}_{v},{r}_{v}]\subseteq [0,\sigma -1]$; the root corresponds to $[0,\sigma -1]$ and its left (right) child to $[0,\lfloor \sigma /2\rfloor ]$ ($[\lfloor \sigma /2\rfloor +1,\sigma -1]$), and these intervals are recursively divided until leaves, each of which corresponds to one symbol. The bit vector ${B}_{v}[1\dots {L}_{v}]$ corresponding to an internal node v is defined as follows. Let ${S}_{v}[1\dots {L}_{v}]$ be the subsequence of S which consists of elements with symbols $[{l}_{v},{r}_{v}]$. Then if the symbol ${S}_{v}\left[i\right]$ corresponds to the left child of v then ${B}_{v}\left[i\right]=0$; otherwise ${B}_{v}\left[i\right]=1$. The wavelet tree requires $(l+o(l\left)\right)\mathrm{log}\sigma $ bits of space, and can be built in $O(l\mathrm{log}\sigma /\sqrt{\mathrm{log}l})$ time [18]. Using wavelet tree for S, the following queries can be solved in $O\left(\mathrm{log}\sigma \right)$ time for each: $\mathtt{access}(i,S)$ returns $S\left[i\right]$, ${\mathtt{rank}}_{c}(i,S)$ returns the number of occurrences of c in $S[1\dots i]$, and ${\mathtt{select}}_{c}(i,B)$ returns the position of the i-th occurrence of c in B if exists or ∅ otherwise (here $c\in [0,\sigma -1]$).

## 3. Overview of the Algorithms of Baswana et al.

#### 3.1. Fault Tolerant DFS Algorithm

**Definition**

**1**

**([4]).**

**Definition**

**2**

**([4]).**

**Lemma**

**1**

**([4]).**

#### 3.2. Dynamic DFS Algorithm

**Lemma**

**2**

**([4]).**

## 4. Query Reduction to Orthogonal Range Search Problem

**Definition**

**3.**

#### 4.1. Original Reduction

#### 4.2. Efficient Reduction

**Lemma**

**3.**

**Claim**

**1.**

**Proof.**

## 5. Linear Space Dynamic DFS

**Lemma**

**4.**

**Proof.**

**Corollary**

**1.**

**Lemma**

**5.**

**Theorem**

**1.**

## 6. Compression of Data Structures

#### 6.1. Range Next Value Query

**Definition**

**4.**

`rank`and

`select`queries on $\mathcal{W}$ [23]. The pseudocode for solving RN query by the wavelet tree for S is given in Algorithm 1. In Algorithm 1, $\mathit{left}\left(v\right)$ and $\mathit{right}\left(v\right)$ stand for the left and right child of the node v, respectively. When calling $\mathrm{RN}(\mathit{root},p,[a,b],[0,\sigma -1\left]\right)$, we can obtain the answer for the RN query with $[a,b]$ and p. Here a pair of the position and the value of the element is returned. If $(0,-1)$ is returned, the answer for the RN query is ∅. The RP queries on S can be solved in a similar way using the same wavelet tree as the RN queries.

Algorithm 1 Range Next Value by Wavelet Tree |

1: function RN($v,p,[a,b],[\alpha ,\omega ]$) |

2: if $a>b$ or $\omega <p$ then return $(0,-1)$ |

3: if $\alpha =\omega $ then return $(a,\alpha )$ |

4: $\gamma \leftarrow \left(\right)open="\lfloor "\; close="\rfloor ">(\alpha +\omega )/2$ |

5: if $p\le \gamma $ then |

6: $(pos,val)\leftarrow \mathrm{RN}(\mathit{left}\left(v\right),p,[{\mathtt{rank}}_{0}({B}_{v},a-1)+1,{\mathtt{rank}}_{0}({B}_{v},b)],[\alpha ,\gamma ])$ |

7: if $pos\ne 0$ then return $({\mathtt{select}}_{0}({B}_{v},pos),val)$ |

8: end if |

9: $(pos,val)\leftarrow \mathrm{RN}(\mathit{right}\left(v\right),p,[{\mathtt{rank}}_{1}({B}_{v},a-1)+1,{\mathtt{rank}}_{1}({B}_{v},b)],[\gamma +1,\omega ])$ |

10: if $pos\ne 0$ then return $({\mathtt{select}}_{1}({B}_{v},pos),val)$ |

11: else return $(0,-1)$ |

12: end function |

#### 6.2. Halving Required Space

**Lemma**

**6.**

`rank`and one

`select`queries, on ${S}_{u}$.

**Proof.**

**Claim**

**2.**

**Proof.**

**Claim**

**3.**

`rank`and one

`select`queries on ${S}_{u}$ for any ${a}^{\prime},{b}^{\prime},c$.

**Proof.**

`select`query itself. ☐

`rank`,

`select`, RN and RP queries on ${S}_{u}$ can be solved in $O\left(\mathrm{log}n\right)$ time for each with a wavelet tree for ${S}_{u}$, we immediately obtain a data structure of $(m+o(m\left)\right)\mathrm{log}n$ bits for the queries Q and ${Q}^{\prime}$. Here the required space of ${B}_{u}$ is again $o\left(m\right)\mathrm{log}n$ bits and does not matter.

**Corollary**

**2.**

#### 6.3. Range Leftmost Value Query

**Definition**

**5.**

**Lemma**

**7.**

`rank`and one

`select`queries, on ${S}_{l}$.

**Proof.**

`rank`and one

`select`queries on ${S}_{l}$, in the same way as Claim 3. ☐

**Lemma**

**8.**

**Proof.**

**Claim**

**4.**

**Proof.**

`rank`queries on ${B}_{v}$: $[{a}_{l},{b}_{l}]=[{\mathtt{rank}}_{0}({B}_{v},a-1)+1,{\mathtt{rank}}_{0}({B}_{v},b)]$ and $[{a}_{r},{b}_{r}]=[{\mathtt{rank}}_{1}({B}_{v},a-1)+1,{\mathtt{rank}}_{1}({B}_{v},b)]$. It can be observed that the element ${S}_{v}\left[{i}^{\prime}\right]$ of ${S}_{v}$ corresponding to the leftmost element ${S}_{l\left(v\right)}\left[i\right]$ in ${S}_{l\left(v\right)}[{a}_{l},{b}_{l}]$ with a value within $[p,q]$ is also the leftmost element in ${S}_{v}[a\dots b]$ with a value within $[p,q]\cap [{l}_{v},\gamma ]$. Here i can be obtained by $\mathrm{RL}(l\left(v\right),[p,q],[{a}_{l},{b}_{l}],[{l}_{v},\gamma ])$ (induction hypothesis) and ${i}^{\prime}={\mathtt{select}}_{0}({B}_{v},i)$. Similarly, the element ${S}_{v}\left[{j}^{\prime}\right]$ of ${S}_{v}$ corresponding to the leftmost element ${S}_{r\left(v\right)}\left[i\right]$ in ${S}_{r\left(v\right)}[{a}_{r},{b}_{r}]$ with a value within $[p,q]$ is also the leftmost element in ${S}_{v}[a\dots b]$ with a value within $[p,q]\cap [\gamma +1,{r}_{v}]$. Again j can be obtained by $\mathrm{RL}(r\left(v\right),[p,q],[{a}_{r},{b}_{r}],[\gamma +1,{r}_{v}])$ (induction hypothesis) and ${j}^{\prime}={\mathtt{select}}_{1}({B}_{v},j)$. Hence ${S}_{v}[min\{{i}^{\prime},{j}^{\prime}\}]$ is the leftmost element we want to know. Now the answer is correctly returned with lines 4–10 of Algorithm 2: lines 7–10 cope with the case the $\mathrm{RL}$ function returns 0. ☐

Algorithm 2 Range Leftmost Value by Wavelet Tree |

1:function RL($v,[p,q],[a,b],[\alpha ,\omega ]$) |

2: if $a>b$ or $[\alpha ,\omega ]\cap [p,q]=\varnothing $ then return 0 |

3: if $[\alpha ,\omega ]\subseteq [p,q]$ then return a |

4: $\gamma \leftarrow \left(\right)open="\lfloor "\; close="\rfloor ">(\alpha +\omega )/2$ |

5: $i\leftarrow \mathrm{RL}(\mathit{left}\left(v\right),[p,q],[{\mathtt{rank}}_{0}({B}_{v},a-1)+1,{\mathtt{rank}}_{0}({B}_{v},b)],[\alpha ,\gamma ])$ |

6: $j\leftarrow \mathrm{RL}(\mathit{right}\left(v\right),[p,q],[{\mathtt{rank}}_{1}({B}_{v},a-1)+1,{\mathtt{rank}}_{1}({B}_{v},b)],[\gamma +1,\omega ])$ |

7: if $i\ne 0$ and $j\ne 0$ then return $min({\mathtt{select}}_{0}({B}_{v},i),{\mathtt{select}}_{1}({B}_{v},j))$ |

8: else if $i\ne 0$ then return ${\mathtt{select}}_{0}({B}_{v},i)$ |

9: else if $j\ne 0$ then return ${\mathtt{select}}_{1}({B}_{v},j)$ |

10: else return 0 |

11: end function |

`rank`and one

`select`query on ${B}_{d}$. Now we do not retain the information of the diagonal points in the wavelet tree, so the overall required space of data structures is $(k+o\left(k\right))\mathrm{log}l+l{H}_{0}\left({B}_{d}\right)+o\left(l\right)\le (k+o\left(k\right))\mathrm{log}l+d\mathrm{log}\frac{el}{d}+o\left(l\right)$ bits.

## 7. More Space-Efficient Dynamic DFS

#### 7.1. Fault Tolerant DFS

**Lemma**

**9.**

#### 7.2. Amortized Update Time Dynamic DFS

Algorithm 3 Creating ${S}_{t}[1\dots {m}_{t}]$ and ${M}_{t}[0\dots {n}_{t}]$ from ${S}_{t}^{\prime}[1\dots {m}_{t}]$ and ${M}_{t}^{\prime}[0\dots {n}_{t}]$ |

1: $i\leftarrow 0$, create ${S}_{t}^{\u2033}[1\dots {m}_{t}]$ and ${M}_{t}^{\u2033}[0\dots {n}_{t}]$ with all elem. 0 |

2: for $k:=1$ to ${m}_{t}$ do |

3: while ${M}_{t}^{\prime}[i+1]<k$ do $\mathrm{inc}\left(i\right)$ |

4: $\mathrm{inc}\left({M}_{t}^{\u2033}[min\{N\left[i\right],N\left[{S}_{t}^{\prime}\left[k\right]\right]\}]\right)$ |

5: end for |

6: for $l:=1$ to ${n}_{t}$ do ${M}_{t}^{\u2033}\left[l\right]\leftarrow {M}_{t}^{\u2033}\left[l\right]+{M}_{t}^{\u2033}[l-1]$ |

7: $i\leftarrow {n}_{t}$ |

8: for $k:={m}_{t}$ down to 1 do |

9: while ${M}_{t}^{\prime}\left[i\right]\ge k$ do $\mathrm{dec}\left(i\right)$ |

10: ${S}_{t}^{\u2033}\left[{M}_{t}^{\u2033}[min\{N\left[i\right],N\left[{S}_{t}^{\prime}\left[k\right]\right]\}]\right]\leftarrow max\{N\left[i\right],N\left[{S}_{t}^{\prime}\left[k\right]\right]\}$ |

11: $\mathrm{dec}\left({M}_{t}^{\u2033}[min\{N\left[i\right],N\left[{S}_{t}^{\prime}\left[k\right]\right]\}]\right)$ |

12: end for |

13: destroy ${S}_{t}^{\prime}$ and ${M}_{t}^{\prime}$, create ${S}_{t}[1\dots {m}_{t}]$ and ${M}_{t}[0\dots {n}_{t}]$ with all elem. 0 |

14: for $k:=1$ to ${m}_{t}$ do $\mathrm{inc}\left({M}_{t}\left[{S}_{t}^{\u2033}\left[k\right]\right]\right)$ |

15: for $l:=1$ to ${n}_{t}$ do ${M}_{t}\left[l\right]\leftarrow {M}_{t}\left[l\right]+{M}_{t}[l-1]$ |

16: $i\leftarrow {n}_{t}$ |

17: for $k:={m}_{t}$ down to 1 do |

18: while ${M}_{t}^{\u2033}\left[i\right]\ge k$ do $\mathrm{dec}\left(i\right)$ |

19: ${S}_{t}\left[{M}_{t}\left[{S}_{t}^{\u2033}\left[k\right]\right]\right]\leftarrow i$ |

20: $\mathrm{dec}\left({M}_{t}\left[{S}_{t}^{\u2033}\left[k\right]\right]\right)$ |

21: end for |

22: destroy ${S}_{t}^{\u2033}$ and ${M}_{t}^{\u2033}$ |

**Theorem**

**2.**

**Theorem**

**3.**

#### 7.3. Worst-Case Update Time Dynamic DFS

**Theorem**

**4.**

**Theorem**

**5.**

## 8. Applications

#### 8.1. Dynamic Connectivity

**Theorem**

**6.**

#### 8.2. Dynamic Biconnectivity/2-Edge-Connectivity

- For each vertex v and each path ${p}^{*}\in {P}_{p}$, solve ${Q}^{\prime}(v,u\left({p}^{*}\right),l\left({p}^{*}\right))$ to get an edge $(v,w)$ and update $H\left(v\right)$ by $g\left(w\right)$.
- For each vertex v and each path ${p}^{*}\in {P}_{p}$, solve ${Q}^{\prime}(v,l\left({p}^{*}\right),u\left({p}^{*}\right))$ to get $(v,w)$ and update $H\left(w\right)$ by $g\left(v\right)$.
- For each vertex v that is in some subtree $\tau \in \mathcal{T}$ initially (i.e., when the initial DTP is calculated), let ${p}_{v}^{*}\in {P}_{t}$ be the path which contains v. Then solve ${Q}^{\prime}(v,u\left({p}_{v}^{*}\right),l\left({p}_{v}^{*}\right))$ to get $(v,w)$ and update $H\left(v\right)$ by $g\left(w\right)$.
- For each vertex v that is in some subtree $\tau \in \mathcal{T}$ initially, let ${p}_{z}^{*}\in {P}_{t}$ be the path which contains ${z}_{v}$. Then solve ${Q}^{\prime}(v,u\left({p}_{z}^{*}\right),l\left({p}_{z}^{*}\right))$ to get $(v,w)$ and update $H\left(v\right)$ by $g\left(w\right)$.

**Lemma**

**10.**

**Proof.**

**Lemma**

**11.**

**Theorem**

**7.**

## Author Contributions

## Funding

## Conflicts of Interest

## Abbreviations

DFS | Depth-First Search |

ORS query | Orthogonal Range Successor query |

ORP query | Orthogonal Range Predecessor query |

HL decomposition | Heavy-Light decomposition |

LCA query | Lowest Common Ancestor query |

## References

- Franciosa, P.G.; Gambosi, G.; Nanni, U. The incremental maintenance of a Depth-First-Search tree in directed acyclic graphs. Inf. Process. Lett.
**1997**, 61, 113–120. [Google Scholar] [CrossRef] - Baswana, S.; Choudhary, K. On dynamic DFS tree in directed graphs. In Proceedings of the 40th International Symposium on Mathematical Foundations of Computer Science (MFCS), Milan, Italy, 24–28 August 2015; Volume 9235, pp. 102–114. [Google Scholar]
- Baswana, S.; Khan, S. Incremental algorithm for maintaining DFS tree for undirected graphs. In Proceedings of the 41st International Colloquium on Automata, Languages, and Programming (ICALP), Copenhagen, Denmark, 8–11 July 2014; Volume 8572, pp. 138–149. [Google Scholar]
- Baswana, S.; Chaudhury, S.R.; Choudhary, K.; Khan, S. Dynamic DFS in undirected graphs: Breaking the O(m) barrier. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), Arlington, VA, USA, 10–12 January 2016; pp. 730–739. [Google Scholar]
- Chen, L.; Duan, R.; Wang, R.; Zhang, H. Improved algorithms for maintaining DFS tree in undirected graphs. arXiv, 2016; arXiv:1607.04913. [Google Scholar]
- Baswana, S.; Chaudhury, S.R.; Choudhary, K.; Khan, S. Dynamic DFS in undirected graphs: Breaking the O(m) barrier. arXiv, 2015; arXiv:1502.02481. [Google Scholar]
- Chen, L.; Duan, R.; Wang, R.; Zhang, H.; Zhang, T. An improved algorithm for incremental DFS tree in undirected graphs. In Proceedings of the 16th Scandinavian Symposium and Workshops on Algorithm Theory (SWAT), Malmö, Sweden, 18–20 June 2018; pp. 16:1–16:12. [Google Scholar]
- Baswana, S.; Goel, A.; Khan, S. Incremental DFS algorithms: A theoretical and experimental study. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), New Orleans, LA, USA, 7–10 January 2018; pp. 53–72. [Google Scholar]
- Khan, S. Near optimal parallel algorithms for dynamic DFS in undirected graphs. In Proceedings of the 29th ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), Washington, DC, USA, 24–26 July 2017; pp. 283–292. [Google Scholar]
- Nakamura, K.; Sadakane, K. A space-efficient algorithm for the dynamic DFS problem in undirected graphs. In Proceedings of the 11th International Conference and Workshops on Algorithms and Computation (WALCOM), Hsinchu, Taiwan, 29–31 March 2017; Volume 10167, pp. 295–307. [Google Scholar]
- Baswana, S.; Gupta, S.K.; Tulsyan, A. Fault tolerant and fully dynamic DFS in undirected graphs: Simple yet efficient. arXiv, 2018; arXiv:1810.01726. [Google Scholar]
- Grossi, R.; Gupta, A.; Vitter, J.S. High-order entropy-compressed text indexes. In Proceedings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), Baltimore, MD, USA, 12–14 January 2003; pp. 841–850. [Google Scholar]
- Frigioni, D.; Italiano, G.F. Dynamically switching vertices in planar graphs. Algorithmica
**2000**, 28, 76–103. [Google Scholar] [CrossRef] - Chan, T.M.; Pătraşcu, M.; Roditty, L. Dynamic connectivity: Connecting to networks and geometry. SIAM J. Comput.
**2011**, 40, 333–349. [Google Scholar] [CrossRef] - Jacobson, G. Space-efficient static trees and graphs. In Proceedings of the 30th Annual Symposium on Foundations of Computer Science (FOCS), Research Triangle Park, NC, USA, 30 October–1 November 1989; pp. 549–554. [Google Scholar]
- Clark, D. Compact Pat Trees. Ph.D. Thesis, University of Waterloo, Waterloo, ON, Canada, 1996. [Google Scholar]
- Raman, R.; Raman, V.; Rao, S.S. Succinct indexable dictionaries with applications to encoding k-ary trees, prefix sums and multisets. ACM Trans. Algorithms
**2007**, 3, 43. [Google Scholar] [CrossRef] - Munro, J.I.; Nekrich, Y.; Vitter, J.S. Fast construction of wavelet trees. Theor. Comput. Sci.
**2016**, 638, 91–97. [Google Scholar] [CrossRef] - Sleator, D.D.; Tarjan, R.E. A data structure for dynamic trees. J. Comput. Syst. Sci.
**1983**, 26, 362–391. [Google Scholar] [CrossRef] - Bender, M.A.; Farach-Colton, M. The LCA problem revisited. In Proceedings of the 4th Latin American Symposium on Theoretical Informatics (LATIN), Punta del Esk, Uruguay, 10–14 April 2000; Volume 1776, pp. 88–94. [Google Scholar]
- Belazzougui, D.; Puglisi, S.J. Range predecessor and Lempel-Ziv parsing. In Proceedings of the Twenty-Seventh Annual ACM-SIAM Symposium on Discrete Algorithms (SODA), Arlington, VA, USA, 10–12 January 2016; pp. 2053–2071. [Google Scholar]
- Yu, C.C.; Hon, W.K.; Wang, B.F. Improved data structures for the orthogonal range successor problem. Comput. Geom.
**2011**, 44, 148–159. [Google Scholar] [CrossRef] - Navarro, G. Wavelet trees for all. J. Discret. Algorithms
**2014**, 25, 2–20. [Google Scholar] [CrossRef] - Kreft, S.; Navarro, G. Self-indexing based on LZ77. In Proceedings of the 22nd Annual Symposium on Combinatorial Pattern Matching (CPM), Palermo, Italy, 27–29 June 2011; Volume 6661, pp. 41–54. [Google Scholar]

**Figure 1.**The configurations of $T\left(w\right)$ and $path(x,y)$ in T that can appear in $Q\left(T\right(w),x,y)$.

**Figure 2.**The configuration of $path(x,y)$ and w in T that can appear in ${Q}^{\prime}(w,x,y)$ and cannot appear in $Q\left(T\right(w),x,y)$.

**Figure 3.**An example of an undirected graph with vertex numbering, its adjacency list, and the corresponding rank space $\mathcal{R}$.

**Figure 4.**(

**Left**) an example of the grid $\mathcal{G}$ and its corresponding array S and bit vector B. Please note that this grid corresponds to the graph in Figure 3. (

**Right**) the upper triangular part ${\mathcal{G}}_{u}$ and its corresponding array ${S}_{u}$ and bit vector ${B}_{u}$.

Worst-Case Update Time | |||
---|---|---|---|

Space (bits) | Fully Dynamic | Incremental | |

[4] | $O\left(m{\mathrm{log}}^{2}n\right)$ | $O\left(\sqrt{mn}{\mathrm{log}}^{2.5}n\right)$ | $O\left(n{\mathrm{log}}^{3}n\right)$ |

[5,7] | $O\left(m{\mathrm{log}}^{2}n\right)$ | $O\left(\sqrt{mn}{\mathrm{log}}^{1.5}n\right)$ | $O\left(n\right)$ |

A | $O\left(m\mathrm{log}n\right)$ | $O\left(\sqrt{mn}{\mathrm{log}}^{0.75+\epsilon}n\right)$ | $O{\left(n\sqrt{\mathrm{log}n}\right)}^{*}$ |

B | $(3m+o(m\left)\right)\mathrm{log}n$ | $O\left(\sqrt{mn}{\mathrm{log}}^{1.25}n\right)$ | $O\left(n\mathrm{log}n\right)$ |

[11] | $O\left(m\mathrm{log}n\right)$ | $O\left(\sqrt{mn}{\mathrm{log}}^{0.5}n\right)$ | − |

© 2019 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Nakamura, K.; Sadakane, K.
Space-Efficient Fully Dynamic DFS in Undirected Graphs ^{†}. *Algorithms* **2019**, *12*, 52.
https://doi.org/10.3390/a12030052

**AMA Style**

Nakamura K, Sadakane K.
Space-Efficient Fully Dynamic DFS in Undirected Graphs ^{†}. *Algorithms*. 2019; 12(3):52.
https://doi.org/10.3390/a12030052

**Chicago/Turabian Style**

Nakamura, Kengo, and Kunihiko Sadakane.
2019. "Space-Efficient Fully Dynamic DFS in Undirected Graphs ^{†}" *Algorithms* 12, no. 3: 52.
https://doi.org/10.3390/a12030052