2-Edge-Connectivity and 2-Vertex-Connectivity of an Asynchronous Distributed Network

TL;DR

This paper introduces a self-stabilizing algorithm for determining 2-edge and 2-vertex connectivity in asynchronous distributed networks, leveraging a depth-first search approach to ensure fault tolerance and network robustness.

Contribution

It presents a novel, non-composite self-stabilizing algorithm for 2-edge and 2-vertex connectivity, with optimal time and space complexities based on depth-first search.

Findings

Algorithm stabilizes in O(dnΔ) rounds

Uses O(n log Δ) bits per processor

Effective for asynchronous distributed networks

Abstract

Self-stabilization for non-masking fault-tolerant distributed system has received considerable research interest over the last decade. In this paper, we propose a self-stabilizing algorithm for 2-edge-connectivity and 2-vertex-connectivity of an asynchronous distributed computer network. It is based on a self-stabilizing depth-first search, and is not a composite algorithm in the sense that it is not composed of a number of self-stabilizing algorithms that run concurrently. The time and space complexities of the algorithm are the same as those of the underlying self-stabilizing depth-first search algorithm which are O(dn\Delta) rounds and O(n\log \Delta) bits per processor, respectively, where \Delta (<= n) is an upper bound on the degree of a node, d (<= n) is the diameter of the graph, and n is the number of nodes in the network.

Full text

**KEY WORDS

**Distributed system, fault-tolerance, self-stabilization, depth-first search tree, bridge, articulation point, bridge-connected component.

I Introduction

A distributed system is a set of processing elements or state machines interconnected by a network of some fixed topology. Distributed systems are exposed to constant changes of their environment and the design of such systems is quite complex, in part due to unpredictable faults. Implicit in the notion of fault is the specification of what constitutes the correct state of the system. A transient fault is an event that may change the state of a system by corrupting the local states of the machines. The property of self-stabilization can recover the system from transient faults and represents a departure from previous approaches to fault tolerance.

The notion of self-stabilization was first proposed by Dijkstra [5, 6]. A system is self-stabilizing if, starting at any state, possibly illegitimate, it eventually converges to a legitimate state in finite time [12, 11]. A self-stabilizing system is capable of tolerating any unexpected transient fault without being assisted by any external agent. Regardless of the initial state, it can reach a legitimate global state in finite time and can remain so thereafter unless it experiences any subsequent fault. In this paper, we propose a simple self-stabilizing algorithm for detecting the bridges, articulation points, and bridge-connected components of an asynchronous distributed network. When a distributed system is modelled as an undirected connected graph, an edge is called a bridge if its removal disconnects the graph whereas an articulation point is a node whose removal disconnects the graph. A maximal component without any bridge of the graph is called a bridge-connected component. Bridge-connectivity (2-edge-connectivity) and biconnectivity (2-vertex-connectivity) call for considerable attention in graph theory since these properties represent the extent to which a graph is connected [13]. In distributed systems, these properties represent the reliability of the network in presence of link or node failures. Moreover, when communication links are expensive, these properties play a vital role to minimize the communication cost.

Several self-stabilizing algorithms for 2-edge-connectivity and 2-vertex-connectivity are available. The algorithm in [1] can find the bridge-connected components by assuming the existence of a depth-first search spanning tree of the system. This algorithm stabilizes in two phases and, for a system with $n$ processors, each phase requires O$(n^{2})$ moves to reach a legitimate configuration by assuming that the preceding phase has stabilized. If a breadth-first search tree of the network is known, then the algorithm in [10] can detect the bridges in O$(n^{3})$ moves and that in [8] can detect the articulation points in O$(n^{3})$ moves. The algorithm in [9] finds the biconnected components in O$(n^{2})$ moves if a breadth-first search tree and all the bridges of the network are known. Each of the algorithms [1, 8, 9, 10] mentioned above requires O$(n\Delta\lg\Delta)$ bits per processor, where $\Delta$ is an upper bound on the degree of a processor. The algorithm proposed by Devismes [4] uses a weaker model (one that does not require every node to have a distinct identifier) and can detect the cut-nodes and bridges in O$(n^{2})$ moves if a depth-first search tree of the network is known. This algorithm is memory efficient (O$(n\lg\Delta+\lg n)$ bits per processor) but does not find the bridge-connected or biconnected components.

It is pointed out in [15] that each of the aforementioned algorithms is just one component of a composite algorithm and hence the time complexity presented is different from that of the composite algorithm. Since the algorithm must run concurrently with a self-stabilizing spanning tree algorithm (which is another component of the composite algorithm), when the last transient fault had elapsed and the spanning tree algorithm has stabilized, the processor may make redundant moves on the spanning tree algorithm which could significantly lengthen the time that the composite algorithm needs to stabilize. In the worst case, the time complexity of the composite algorithm is the $product$ of the time complexities of the algorithms that make up the composite algorithm and is thus bounded below by that of the spanning tree algorithm. Addressing all these issues, Tsin [15] has shown how to incorporate Tarjan’s depth-first-search based algorithm for biconnectivity into the self-stabilizing depth-first search algorithm of Collin and Dolev [3] to produce a self-stabilizing algorithm for bridge-connectivity and biconnectivity. The time and space complexities of the resulting algorithm are bounded above by those of the depth-first search algorithm. Following this elegant approach [15], our algorithm simplifies all existing algorithms for bridge-connectivity and biconnectivity [1, 4, 8, 9, 10] by embedding the detection method of bridges and articulation points in the self-stabilizing depth-first search algorithm of Collin and Dolev [3] and by avoiding any distributed protocol composition. The proposed algorithm also determines all the bridge-connected components since, upon stabilization of the algorithm, all the nodes of the same component contain the same identifier. The space complexity is also significantly improved in our algorithm. The space requirement for each of the algorithms of [1, 8, 9, 10] is O$(n^{2}\log(n))$ bits per processor for a system with $n$ processors. This is due to the propagation of a set of non-tree edges that bypass a tree edge in the depth-first search spanning tree of the system. However, we show that passing only the size of that set is sufficient for detecting all the bridges and articulation points which substantially reduces the size of the message. Specifically, the time complexity of our algorithm is $O(dn\Delta)$ rounds and the space complexity for every processor is O($n\log\Delta$) bits. Note that the space complexity for the self-stabilizing depth-first algorithm of Collin and Dolev [3] is O($n\log\Delta$) bits per processor and the time complexity is $O(dn\Delta)$ rounds. The model we use is the same as that of Collin and Dolev [3], which is weaker than that used in [1, 2, 8, 9, 10].

II Computational Model

The distributed system is represented by an undirected connected graph $G=(V,E)$. The set of nodes $V$ in $G$ represents the set of processors $\{v_{1},v_{2},\cdots,v_{n}\}$, where $n$ is the total number of processors in the system, and $E$ represents the set of bidirectional communication links between two processors. We shall use the terms node and processor (edge and link, respectively) interchangeably throughout this paper. We assume that the graph is bridgeless.

All the processors, except $v_{1}$, are anonymous. The processor $v_{1}$ is a special processor and is designated as the root. For the processors $v_{i}$, $2\leq i\leq n$, the subscripts $2,\cdots,n$ are used for ease of notation only and must not be interpreted as identifiers. Two processors are neighboring if they are connected by a link. The processors run asynchronously and the communication facilities are limited only between the neighboring processors. Communication between the neighbors is carried out using shared communication registers (called registers throughout this paper). Each register is serializable with respect to read and write operations.

Every processor $v_{i}$, $1\leq i\leq n$, contains a register. A processor can both read and write to its own register. It can also read the registers of the neighboring processors but cannot write to those registers. The contents of the registers are divided into fields. Each processor $v_{i}$ orders its edges by some arbitrary ordering $\alpha_{i}$. For any edge $e=(v_{i},v_{j})$, $\alpha_{i}(j)$ ($\alpha_{j}(i)$, respectively) denotes the edge index of $e$ according to $\alpha_{i}$ ($\alpha_{j}$, respectively). Furthermore, for every processor $v_{i}$ and any edge $e=(v_{i},v_{j})$, $v_{i}$ knows the value of $\alpha_{j}(i)$.

We consider a processor and its register to be a single entity, thus the state of a processor fully describes the value stored in its register, program counter, and the local variables. Let $\chi_{i}$ be the set of possible states of processor $v_{i}$. A configuration $c\in(\chi_{1}\times\chi_{2}\times\cdots\chi_{n})$ of the system is a vector of states, one for each processor. Execution of the algorithm proceeds in steps (or atomic steps) using read/write atomicity. An atomic step of a processor consists of an internal computation followed by either read or write, but not both. Processor activity is managed by a scheduler (also called daemon). At any given configuration, the scheduler activates a single processor which executes a single atomic step.

An execution of the system is an infinite sequence of configurations $\Re=(c_{0},c_{1},\cdots,c_{i},c_{i+1},$ $\cdots)$ such that for $i\geq 0$, $c_{i}\rightarrow c_{i+1}$ (called a single computation step ) denotes that configuration $c_{i+1}$ can be reached from configuration $c_{i}$ by executing on step. A fair execution is an infinite execution in which every processor executes atomic steps infinitely often. A suffix of a sequence of configurations $(c_{0},c_{1},\cdots,c_{i},c_{i+1},\cdots)$ is a sequence $(c_{k},c_{k+1},\cdots)$, where $k\geq 0$. The finite sequence $(c_{0},c_{1},\cdots,c_{k-1})$ is a prefix of the sequence of configurations. A task is defined by a set of executions, called legal executions. A distributed algorithm is self-stabilizing for a task if every fair execution of the algorithm has a suffix belonging to the set of legal executions of that task. The time complexity of the algorithm is expressed in terms of the number of rounds [7]. The first round of an execution $\Re$ is the shortest prefix of $\Re$ in which every processor executes at least one step. Let $\Re=\Re_{1}\Re_{2}$ such that $\Re_{1}$ is the prefix consisting of the first $k$ rounds of $\Re$. Then the ($k+1$)-th round of $\Re$ is the first round of $\Re_{2}$.

III The Algorithm

The algorithm uses the self-stabilizing depth-first search algorithm of Collin and Dolev [3] to construct a depth-first search spanning tree. In the self-stabilizing depth-first search algorithm of Collin and Dolev [3], every processor $v_{i}$ has a field, denoted by $path_{i}$, in its register. At any point of time during the execution of the algorithm, $path_{i}$ contains the sequence of indices of the links on a path connecting the root $v_{1}$ with node $v_{i}$. The algorithm uses a lexicographical order relation $\prec$ on the path representation and the concatenation of any link with a path is denoted by the operator $\oplus$. The root processor $v_{1}$ always writes $\bot$ in its $path_{1}$ field and, in the lexicographical order relation, $\bot$ is the minimal character. When a depth-first search tree is constructed in the network, $path_{i}$ contains the smallest (with respect to the lexicographical order $\prec$) path connecting $v_{1}$ with $v_{i}$. The last links on the smallest paths of $v_{i}$, $i\geq 2$, form a depth-first search tree, called the first depth-first search tree. Given that in the first depth-first search tree, a node $v_{j}$ is an ancestor of a node $v_{i}$ if the smallest path of $v_{i}$ contains the smallest path of $v_{j}$, then, the node $v_{j}$ is an ancestor of a node $v_{i}$ if $path_{j}$ is a prefix of $path_{i}$, i.e. $(\exists s)(path_{i}=path_{j}\oplus s)$. If there exists a unique neighbor $v_{j}$ of $v_{i}$ such that $path_{i}=path_{j}\oplus\alpha_{j}(i)$, then $v_{j}$ is the parent of $v_{i}$. The degree of a processor $v_{i}$, denoted by $\delta_{i}$, is the number of incident edges (links) on $v_{i}$. Once a depth-first search tree is constructed, at each processor $v_{i}$, the type of each incident link ($v_{i},v_{j}$) (or ($v_{j},v_{i}$)) can be determined by $path_{i},path_{j},\alpha_{i}(j)$, and $\alpha_{j}(i)$ in the following ways:

• •

The link ($v_{j},v_{i}$) is a parent link if and only if $path_{i}=path_{j}\oplus\alpha_{j}(i)$;

• •

The link ($v_{i},v_{j}$) is a child link if and only if $path_{j}=path_{i}\oplus\alpha_{i}(j)$;

• •

The link ($v_{i},v_{j}$) is an outgoing non-tree edge (i.e. it is a non-tree link and $v_{j}$ is an ancestor of $v_{i}$) if and only if ($\exists s$)(($path_{i}=path_{j}\oplus s$)$\wedge$($s\not=\alpha_{j}$($i$))); The total number of outgoing non-tree edges incident on processor $v_{i}$ is denoted by $out_{i}$.

• •

The link ($v_{j},v_{i}$) is an incoming non-tree edge (i.e. it is a non-tree link and $v_{j}$ is a descendant of $v_{i}$) if and only if ($\exists s$)(($path_{j}=path_{i}\oplus s$)$\wedge$($s\not=\alpha_{i}$($j$))); The total number of incoming non-tree edges incident on processor $v_{i}$ is denoted by $in_{i}$.

We omit the description of that part of the algorithm for constructing a depth-first search tree $T$, as it is available in [3]. The idea underlying our algorithm is to count the total number of non-tree edges that bypass a tree edge in $T$. A non-tree edge ($v_{k},v_{l}$) ($v_{k}$ is a descendant of $v_{l}$) bypasses a tree edge ($v_{i},v_{j}$) ($v_{i}$ is the parent of $v_{j}$) if and only if $v_{k}$ is a descendant of $v_{j}$ while $v_{l}$ is an ancestor of $v_{i}$. The total number of non-tree edges bypassing the parent link of processor $v_{i}$ is denoted by $count_{i}$. During the execution of the algorithm this number is propagated towards the root whereas in [1, 10, 8, 9], for every node $v_{i}$, the whole set of non-tree edges bypassing the parent link of $v_{i}$ is calculated and routed towards the root. Since, in our algorithm, only the cardinality of the set is propagated, the message cost is drastically reduced. IN $T$, let $in_{i}$ and $out_{i}$ be the number of incoming non-tree edges and the number of outgoing non-tree edges, respectively, incident on $v_{i}$, and $C_{i}$ be the set of children of $v_{i}$, and $incoming(v_{j},v_{i})$ be the number of incoming non-tree edges ($v_{l},v_{i}$) such that $v_{l}$ is a descendant of $v_{j}\in C_{i}$. Then $count_{i}$ is calculated recursively as follows:

$count_{i}:=\underset{v_{j}\in C_{i}}{\sum}count_{j}-in_{i}+out_{i};$

The algorithm is based on the Theorem 1 and Theorem 2 due to Tarjan [14].

Theorem 1

• (i)

If a non-root node $v_{i}$ has a child $v_{j}$ in $T$, then $v_{i}$ is an articulation point of $G$ if and only if $count_{j}=incoming(v_{j},v_{i})$.

• (ii)

The root $v_{1}$ is an articulation point of $G$ if and only if $v_{1}$ has two or more children.

Theorem 2

Let ($v_{i},v_{j}$) be a tree edge in $T$ such that $v_{i}$ is the parent of $v_{j}$. Then ($v_{i},v_{j}$) is a bridge in $G$ if and only if $count_{j}=0$.

Corollary 1 follows from Theorem 1 and Theorem 2.

Corollary 1

Each of the end nodes of a bridge is an articulation point unless it is a node of degree one.

Remark 1

For each leaf node $v_{i}$, $in_{i}=0$ and $count_{i}=out_{i}$.

In order to extend this depth-first search algorithm to find the bridges and articulation points, and bridge-connected components every processor $v_{i}$, in addition to the field $path_{i}$, maintains two fields: $count_{i}$ and $bcc_{i}$. The field $bcc_{i}$ is a unique identifier of the bridge-connected component containing $v_{i}$. For every bridge-connected component, a representative node is defined. A representative node $v_{j}$ of a bridge-connected component is the ancestor of all other nodes of the component containing $v_{j}$. When the algorithm stabilizes, every bridge-connected component is uniquely identified by the $path$-value of its representative node, and $bcc$-fields of all nodes of this component contain this $path$-value.

Lemma 3

A node $v_{i}$ is a representative node if and only if $count_{i}=0$.

Proof:

Let $v_{i}$ be a representative node and $count_{i}>0$. Let $(v_{m},v_{l})$ be a non-tree edge such that $v_{l}$ is an ancestor and $v_{m}$ is a descendant of $v_{i}$. Node $v_{l}$ can be reached from $v_{i}$ using the tree path $v_{i}-v_{m}$ followed by the non-tree edge ($v_{m},v_{l}$) while $v_{l}$ can also be reached from $v_{i}$ using another path $v_{i}-v_{l}$ and these two paths are disjoint. That is, the ancestor $v_{l}$ is bridge-connected to $v_{i}$ which contradicts that $v_{i}$ is a representative node. Again, by Theorem 2, if $count_{i}=0$ then no ancestor of $v_{i}$ can be reached from $v_{i}$ when the parent link of $v_{i}$ is removed. Hence $v_{i}$ is a representative node of the bridge-connected component containing $v_{i}$, ∎

During the execution of the algorithm, every non-root node $v_{i},i\geq 2$, repeatedly reads in $count_{j}$ of every $v_{j}\in C_{i}$, and based on $in_{i}$ and $out_{i}$, it counts the value $count_{i}$. Furthermore, every representative node $v_{i}$ repeatedly writes its own path value $path_{i}$ into $bcc_{i}$ field and every non-representative node $v_{l}$ repreatedly reads in $bcc_{m}$ of its parent $v_{m}$ and writes this value into $bcc_{l}$. The root $v_{1}$ always writes 0 into $count_{1}$ field and $\bot$ (i.e. $path_{1}$ value) into $bcc_{1}$ field.

The algorithm is presented as the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm. The functions read and write are the functions for reading from and writing to a register, respectively. The fields in the register of $v_{i}$, $1\leq i\leq n$, are: $path_{i}$, $count_{i}$, $bcc_{i}$; the local variables are $path$, $read\_path_{j}$, $read\_count_{j}$, and $read\_bcc_{j}$ ($1\leq j\leq\delta_{j}$).

Theorem 4

For every fair execution of the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm, there is a suffix in which for every node $v_{i}$, $1\leq i\leq n$, $bcc_{i}=path_{t}$ in every configuration, where $v_{t}$, $1\leq t\leq n$, is the representative node of the bridge-connected component containing $v_{i}$.

Proof:

In the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm, new instructions for determining the bridges, and articulation points are embedded in the self-stabilizing depth-first search algorithm of Collin and Dolev [3]. These new instructions do not affect the original function of the depth-first search algorithm. Therefore, by Theorem 3.2 in [3], for every fair execution of the 3-EDGE-CONNECTIVITY algorithm, there is a suffix $S$ of the execution in which $path_{i}$, $1\leq i\leq n$, contains the correct value in every configuration. Suppose the execution has reached a configuration $c$ in $S$. By Observation 3.1 in [3], the correct values in $path_{i}$, $1\leq i\leq n$, specify a depth-first search tree $T$.

Let $v_{i}$ be any leaf node in $T$. Since $path_{j}$, $1\leq i\leq n$, is correctly determined, after $v_{i}$ reads in the $path$ field from each outgoing non-tree link, $count_{i}$ value is correctly determined. Let $S^{\prime}$ be a suffix of the execution in which all the nodes on level $h$ or higher (i.e. farther from the root) have correctly computed their $count$ values. Consider any non-leaf node $v_{i}$, on level $h-1$. By the induction hypothesis, for each $v_{j}\in C_{i}$, the values of $count_{j}$ are correctly calculated. Therefore, $v_{i}$ correctly calculates $count_{i}$. Hence, there is a suffix of the suffix $S^{\prime}$ in which for every configuration, $count_{i}$ are correctly computed for every node $v_{i}$, $1\leq i\leq n$.

Suppose the execution has reached a configuration in the aforementioned suffix of suffix $S^{\prime}$. The root node $v_{1}$ is a representative node and always correctly writes the value of $path_{1}$ (i.e. $\bot$) into the field $bcc_{1}$. Let $S^{\prime\prime}$ be a suffix in the suffix $S^{\prime}$ of the execution in which, for every node $v_{m}$ on level $h$ or lower (i.e. closer to the root), $bcc_{m}=path_{l}$, where $v_{l}$ is the representative node of the bridge-connected component containing $v_{m}$. Let $v_{i}$ be any non-root node on level $h+1$. The value $next_{i}$ can be read from $S_{i}$ which is correctly calculated. If $v_{i}$ is a representative node, then $v_{i}$ correctly writes $path_{i}$ into $bcc_{i}$. If $v_{i}$ is not a representative node, then $v_{i}$ reads in the $bcc$-field of its parent which is correct by the induction hypothesis and writes it into $bcc_{i}$. Hence, there is a suffix of the fair execution in which for every node $v_{i}$, $1\leq i\leq n$, $bcc_{i}=path_{t}$ in every configuration, where $v_{t}$, $1\leq t\leq n$, is the representative node of the bridge-connected component containing $v_{i}$. ∎

Lemma 5

When the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm stabilizes, all the bridges, articulation points, and bridge-connected components are determined.

Proof:

When the algorithm stabilizes, by Theorem 4, every node $v_{i},1\leq i\leq n,$ knows its children, parent, all incident tree-edges and non-tree edges, $count_{i}$ values, and $bcc_{i}$ values. By Theorem 2, any tree edge ($v_{i},v_{j}$) with $count_{i}=count_{j}=0$ is a bridge, and, by Corollary 1, each of these two nodes is an articulation point unless its degree is one. By Theorem 1, any other non-root node $v_{i}$ having a child $C_{j}$ such that $count_{j}=incoming(v_{j},v_{i})$ is an articulation point. If the root $v_{1}$ has more than one child then $v_{1}$ is an articulation point. Every bridge-connected component has a unique representative node and, by Theorem 4, the path value of this node is written into $bcc$ field of every node of this component. Hence $bcc_{i}$ value of every node $v_{i}$, $1\leq i\leq n$, uniquely identifies the bridge-connected component containing $v_{i}$. ∎

Lemma 6

The 2-EDGE & 2-VERTEX CONNECTIVITY algorithm stabilizes in O($dn\Delta$) rounds, where $\Delta$ is an upper bound on the degree of a node, $d$ is the diameter of the graph.

Proof:

It is easily verified that the new instructions added to the depth-first search algorithm of Collin and Dolev [3] only increase the time complexity for constructing a depth-first search tree by a constant factor. The for loop for computing the $count$-values takes $O(H)$ rounds, where $H$ is the height of $T$ and the for loop for computing the $bcc$ values takes O(1) rounds. Therefore, the time required by the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm remains same as that of the underlying depth-first search algorithm (i.e. O($dn\Delta$) rounds). ∎

Lemma 7

The space complexity of the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm is O($n\log\Delta$) bits per processor.

Proof:

In the depth-first search algorithm of Collin and Dolev [3], the space required by every processor is O($n\log\Delta$) bits. This is the space required to store the path value of the processor. In the 2-EDGE & 2-VERTEX CONNECTIVITY algorithm, $bcc$ field requires O($n\log\Delta$) bits, and $count$ filed requires O($\log(n\Delta)$) $\approx$ O($\log n$) bits. The space complexity per processor is thus O($n\log\Delta$) bits. ∎

Figure 1 is a depth-first spanning tree of the corresponding undirected graph. An execution of our algorithm over this tree is shown below.

The $count$ values at non-root nodes $v_{4}$, $v_{6}$, $v_{11}$, and $v_{14}$ are 0, and hence, by Lemma 5, the bridges are $(v_{11},v_{14})$, $(v_{10},v_{11})$, $(v_{5},v_{6})$, $(v_{1},v_{4})$. The articulation points are $v_{1}$, $v_{4}$, $v_{5}$, $v_{6}$, $v_{10}$, $v_{11}$, $v_{14}$, and bridge-connected components are: $\{v_{1},v_{2},v_{3}\}$, $\{v_{4},v_{5},v_{10}\}$, $\{v_{6},v_{7},v_{8},v_{9}\}$, $\{v_{11},v_{12},v_{13}\}$, and $\{v_{14},v_{15},v_{16}\}$.

IV Conclusion

We have presented an algorithm for the 2-edge-connectivity and 2-vertex-connectivity problem based on a self-stabilizing depth-first search algorithm. The algorithm constructs a depth-first search tree in $O(dn\Delta)$ rounds and then determines the bridges, articulation points, and bridges-connected components based on the depth-first search tree. In the worst case, when $d=\Delta=n$, our algorithm requires $O(n^{3})$ rounds. Clearly, the time complexity of our algorithm is dominated by the time spent in constructing the depth-first search tree. Should there be an improvement made on the time bound required to construct the depth-first search tree, the time complexity of our algorithm will improve as well.