Biconnected Components

The concept of biconnected components is based on the concept of the disc and low values algorithms. This article aims to focus on the algorithm developed by Robert Tarjan and John Hopcroft's view of biconnected components in a graph data structure. The maximal sub-graph is known to be the concept behind Biconnected Components.

Biconnected components are a part of the graph data structure created. This article will dive deep into finding the biconnected components in a given graph data structure. We will look for the articulation points using the depth-first search and store the visited edges in a stack. When the articulation points are found, the edges stored in the stack data structure will form an entity of biconnected components.

C++ code

// Here we are writing down the C++ programming language code to 
// demonstrate the concept of Biconnected Components with its relevant code
// and output backed by valid syntax to replicate personalized needs
#include <iostream>
#include <list>
#include <stack>
#define NIL -1
using namespace std;
int count = 0;
// the below class is useful while creating the edges for graph data 
// structure which will be called from the main driver code functionality
class Edge {
public:
	int u;
	int v;
	Edge(int u, int v);
};
Edge::Edge(int u, int v)
{
	this->u = u;
	this->v = v;
}

//Below, we are trying to represent a class that represents a directed 
// graph data structure
class Graph {
	int V; // variable 'V' represents no. of vertices
	int E; // variable 'E' represents no. of edges
	list<int>* adj; // here, we have defined a dynamic array of adjacency lists

	// the below code snippet is a recursive Depth First Search 
	// based function used by the function bcc() to traverse the graph data structure
	void BCCUtil(int u, int disc[], int low[],
	// C++ code snippet to create a list 			
               list<Edge>* st, int parent[]);

public:
             // the adjacent code snippet is a constructor of the graph
	Graph(int V); 
             // the below function helps us in  adding an edge 
            // to the graph data structure during the traversal of the matrix graph
	void addEdge(int v, int w); 
// it helps us in printing the strongly connected components
void BCC(); 
};

Graph::Graph(int V)
{
	this->V = V;
	this->E = 0;
	adj = new list<int>[V];
}

void Graph::addEdge(int v, int w)
{
	adj[v].push_back(w);
	E++;
}

// the below is a recursive function helping us with finding and printing the strong articulated points of graph data structure that are connected
void Graph::BCCUtil(int u, int disc[], int low[], list<Edge>* st,
// beginning of the recursive function
int parent[])
{
// Static variable in Java/C/C++ programming languages is used for simplicity
//  we can avoid using a static variable by applying a simple trick of passing a pointer variable
	static int time = 0;
// here, we are trying to initialize the discovery time and low value
	disc[u] = low[u] = ++time;
	int children = 0;
// the below snippet goes through all the vertices and adjacencies to list
	list<int>::iterator i;
// the below for loop helps us in looping through adjacencies of the entire graph data structure
	for (i = adj[u].begin(); i != adj[u].end(); ++i) {
		int v = *i; // here v is the current adjacent of 'u.'

		if (disc[v] == -1) {
			children++;
			parent[v] = u;
// the below code snippet helps us in storing the edge in the 
// temporary stack data structure while it is traversing
			st->push_back(Edge(u, v));
			BCCUtil(v, disc, low, st, parent);

// cementing the edge case in a lower variable			
low[u] = min(low[u], low[v]);
if ((disc[u] == 1 && children > 1) || (disc[u] > 1 && low[v] >= disc[u])) {
// the below while loop helps us in looping through adjacencies of the entire graph data structure
while (st->back().u != u || st->back().v != v) {
cout << st->back().u << "--" << st->back().v << " ";
					st->pop_back();
				}
				cout << st->back().u << "--" << st->back().v;
				st->pop_back();
				cout << endl;
				count++;
			}
		}

	
else if (v != parent[u]) {
low[u] = min(low[u], disc[v]);
			if (disc[v] < disc[u]) {
				st->push_back(Edge(u, v));
			}
		}
	}
}

// The below BCC() function helps us in doing  Depth First Search traversal
void Graph::BCC()
{
	int* disc = new int[V];
	int* low = new int[V];
	int* parent = new int[V];
	list<Edge>* st = new list<Edge>[E];

// the below code snippet helps us in initializing the  disc and low, and 
// the parent arrays of the matrix graph data structure 
	for (int i = 0; i < V; i++) {
		disc[i] = NIL;
		low[i] = NIL;
		parent[i] = NIL;
	}
// the below for loop helps us in looping through adjacencies of the entire graph data structure
	for (int i = 0; i < V; i++) {
		if (disc[i] == NIL)
			BCCUtil(i, disc, low, st, parent);

		int j = 0;
// below, we have defined the edge case of the stack to pop all 
// the edges of graph data structure if the stack is found not to be empty
		while (st->size() > 0) {
			j = 1;
			cout << st->back().u << "--" << st->back().v << " ";
			st->pop_back();
		}
		if (j == 1) {
			cout << endl;
			count++;
		}
	}
}

// The main driver code functionality starts from here
int main()
{
    //the below lines of code are the matrix edges of the graph data structure
	Graph g(12);
	g.addEdge(0, 1);
	g.addEdge(1, 0);
	g.addEdge(1, 2);
	g.addEdge(2, 1);
	g.addEdge(1, 3);
	// the left arial of one ends from here
	g.addEdge(3, 1);
	g.addEdge(2, 3);
	g.addEdge(3, 2);
	g.addEdge(2, 4);
	// the left arial of two ends from here
	g.addEdge(4, 2);
	g.addEdge(3, 4);
	// the left arial of three ends from here
	g.addEdge(4, 3);
	// the left arial of four ends from here
	g.addEdge(1, 5);
	g.addEdge(5, 1);
	g.addEdge(0, 6);
	g.addEdge(6, 0);
	g.addEdge(5, 6);
	// the left arial of six ends from here
	g.addEdge(6, 5);
	g.addEdge(5, 7);
	g.addEdge(7, 5);
	g.addEdge(5, 8);
	// the left arial of five ends from here
	g.addEdge(8, 5);
	// the left arial of seven ends from here
	g.addEdge(7, 8);
	// the left arial of six ends from here
	g.addEdge(8, 7);
	g.addEdge(8, 9);
	g.addEdge(9, 8);
	g.addEdge(10, 11);
	g.addEdge(11, 10);
	g.BCC();
	cout << "Above are edges of " << count << " the biconnected components in graph data structure ";
	return 0;
// The main driver code functionality ends from here
}

Output:

4--2 3--4 3--1 2--3 1--2
8--9
8--5 7--8 5--7
6--0 5--6 1--5 0--1 
10--11
Above are the edges of 5 of the biconnected components in the graph data structure.

Java Script Code

// Here we are writing down the JavaScript programming language code to 
// demonstrate the concept of Biconnected Components with its relevant code
// and output backed by valid syntax to replicate personalized needs

<script>
// the below class is useful while creating the edges for graph data 
// structure which will be called from the main driver code functionality

class Edge
{
constructor(u,v){
this.u = u;
this.v = v;
	}
}

//Below, we are trying to represent a class that represents a directed 
// graph data structure
class Graph
{
	// the below code snippet helps us in creating a constructor for the graph data structure 
	constructor(v)
	{
		this.count=0;
		this.time = 0;
		this.V = v;
		this.E = 0;
		this.adj = new Array(v);
		for (let i = 0; i < v; ++i)
			this.adj[i] = [];
	}
	
	// the below code snippet is a function that helps us in 
             // adding an edge to the graph data structure during matrix traversal
	addEdge(v,w)
	{
		this.adj[v].push(w);
		this.E++;
	}
	
	// the below code snippet is a recursive Depth First Search 
	// based function used by the function bcc()
	BCCUtil(u,disc,low,st,parent)
	{
		// the below code snippet helps us in initialize the discovery 
		// time and the lower value
		disc[u] = low[u] = ++this.time;
		let children = 0;

		// the below for loop helps us in going through all the vertices adjacent to the 
                            // mentioned javascript condition 
		
		for(let it of this.adj[u].values()) {
			let v = it; // v is currently adjacent to 'u.'

// If v is not visited yet, then recur for it
			if (disc[v] == -1) {
				children++;
				parent[v] = u;

				// store the edge in the stack
				st.push(new Edge(u, v));
				this.BCCUtil(v, disc, low, st, parent);


// Case 1 -- per Strongly Connected Components Article
				if (low[u] > low[v])
					low[u] = low[v];

// If ?u? is an articulation point, pop all edges from the m stack till u -- v
				if ((disc[u] == 1 && children > 1) || (disc[u] > 1 && low[v] >= disc[u])) {
					while (st[st.length-1].u != u || st[st.length-1].v != v) {
						document.write(st[st.length-1].u + "--" + st[st.length-1].v + " ");
						st.pop();
					}
					document.write(st[st.length-1].u + "--" + st[st.length-1].v + " <br>");
					st.pop();

					this.count++;
				}
			}

	
			else if (v != parent[u] && disc[v] < disc[u] ) {
				if (low[u] > disc[v])
					low[u] = disc[v];

				st.push(new Edge(u, v));
			}
		}
	}
	
	// The below code snippet is a function to do DFS traversal. It uses 
	// BCCUtil()
	BCC()
	{
		let disc = new Array(this.V);
		let low = new Array(this.V);
		let parent = new Array(this.V);
		let st = [];

//the below for loop helps us to initialize disc and low, and parent 
// arrays
		for (let i = 0; i < this.V; i++) {
			disc[i] = -1;
			low[i] = -1;
			parent[i] = -1;
		}
// the below for loop helps us in looping through adjacencies of the entire graph data structure
		for (let i = 0; i < this.V; i++) {
			if (disc[i] == -1)
				this.BCCUtil(i, disc, low, st, parent);

			let j = 0;

// the below condition helps us to check if the stack is not empty, pop 
// all edges from a stack of our graph data structure
			while (st.length > 0) {
				j = 1;
				document.write(st[st.length-1].u + "--" + st[st.length-1].v + " ");
				st.pop();
			}
			if (j == 1) {
				document.write("<br>");
				this.count++;
			}
	}
}
}

// The main driver code functionality starts from here

let g = new Graph(12);

g.addEdge(0, 1);
	g.addEdge(1, 0);
	g.addEdge(1, 2);
	g.addEdge(2, 1);
	g.addEdge(1, 3);
	// the left arial of one ends from here
	g.addEdge(3, 1);
	g.addEdge(2, 3);
	g.addEdge(3, 2);
	g.addEdge(2, 4);
	// the left arial of two ends from here
	g.addEdge(4, 2);
	g.addEdge(3, 4);
	// the left arial of three ends from here
	g.addEdge(4, 3);
	// the left arial of four ends from here
	g.addEdge(1, 5);
	g.addEdge(5, 1);
	g.addEdge(0, 6);
	g.addEdge(6, 0);
	g.addEdge(5, 6);
	// the left arial of six ends from here
	g.addEdge(6, 5);
	g.addEdge(5, 7);
	g.addEdge(7, 5);
	g.addEdge(5, 8);
	// the left arial of five ends from here
	g.addEdge(8, 5);
	// the left arial of seven ends from here
	g.addEdge(7, 8);
	// the left arial of six ends from here
	g.addEdge(8, 7);
	g.addEdge(8, 9);
	g.addEdge(9, 8);
	g.addEdge(10, 11);
	g.addEdge(11, 10);
	g.BCC();


document.write("Above are the edges of" + g.count + "the biconnected components in graph data structure");

// The main driver code functionality ends from here
</script>

Output:

4--2 3--4 3--1 2--3 1--2 
8--9 
8--5 7--8 5--7 
6--0 5--6 1--5 0--1 
10--11 Above are five biconnected components in the graph

Java Code

// Here we are writing down the Java programming language code to 
// demonstrate the concept of Biconnected Components with its relevant code
// and output backed by valid syntax to replicate personalized needs
import java.io.*;
import java.util.*;

//Below, we are trying to represent a class that represents a directed 
// graph data structure
class Graph {
	private int V, E; // No. of vertices & Edges respectively
	private LinkedList<Integer> adj[]; // Adjacency List

	// Count is several biconnected components. 
             // time is used to find discovery times
	static int count = 0, time = 0;
// the below class is useful while creating the edges for graph data 
// structure which will be called from the main driver code functionality
	class Edge {
		int u;
		int v;
		Edge(int u, int v)
		{
			this.u = u;
			this.v = v;
		}
	};

	// the below code snippet helps us with creating a constructor
	Graph(int v)
	{
		V = v;
		E = 0;
		adj = new LinkedList[v];
		for (int i = 0; i < v; ++i)
			adj[i] = new LinkedList();
	}

// the below code snippet is a recursive Depth First Search 
// based function used by the function bcc()

	void addEdge(int v, int w)
	{
		adj[v].add(w);
		E++;
	}
	void BCCUtil(int u, int disc[], int low[], LinkedList<Edge> st,
	int parent[])
	{

// Initialize discovery time and low value
		disc[u] = low[u] = ++time;
		int children = 0;

// the iterator below goes through all the vertices adjacent to this
		Iterator<Integer> it = adj[u].iterator();
		while (it.hasNext()) {
			int v = it.next(); // v is currently adjacent to 'u.'

			// If v is not visited yet, then recur for it
			if (disc[v] == -1) {
				children++;
				parent[v] = u;

				// store the edge in the stack
				st.add(new Edge(u, v));
				BCCUtil(v, disc, low, st, parent);

			
				if (low[u] > low[v])
					low[u] = low[v];

				if ((disc[u] == 1 && children > 1) || (disc[u] > 1 && low[v] >= disc[u])) {
				while (st.getLast().u != u || st.getLast().v != v) {
						System.out.print(st.getLast().u + "--" + st.getLast().v + " ");
						st.removeLast();
					}
					System.out.println(st.getLast().u + "--" + st.getLast().v + " ");
					st.removeLast();

					count++;
				}
			}

		
			else if (v != parent[u] && disc[v] < disc[u] ) {
				if (low[u] > disc[v])
					low[u] = disc[v];

				st.add(new Edge(u, v));
			}
		}
	}

	// The function to do DFS traversal. It uses BCCUtil()
	void BCC()
	{
		int disc[] = new int[V];
		int low[] = new int[V];
		int parent[] = new int[V];
		LinkedList<Edge> st = new LinkedList<Edge>();

		// Initialize disc and low, and parent arrays
		for (int i = 0; i < V; i++) {
			disc[i] = -1;
			low[i] = -1;
			parent[i] = -1;
		}

		for (int i = 0; i < V; i++) {
			if (disc[i] == -1)
				BCCUtil(i, disc, low, st, parent);

			int j = 0;

// below, we have defined the edge case of the stack to pop all 
// the edges of graph data structure if the stack is found not to be 
// empty

			while (st.size() > 0) {
				j = 1;
				System.out.print(st.getLast().u + "--" + st.getLast().v + " ");
				st.removeLast();
			}
			if (j == 1) {
				System.out.println();
				count++;
			}
		}
	}
// The main driver code functionality starts from here
	public static void main(String args[])
	{
	    // below are the matrix edges of the graph data structure
		Graph g = new Graph(12);
		g.addEdge(0, 1);
		g.addEdge(1, 0);
		g.addEdge(1, 2);
		g.addEdge(2, 1);
		g.addEdge(1, 3);
		// the left arial of one ends from here
		g.addEdge(3, 1);
		g.addEdge(2, 3);
		g.addEdge(3, 2);
		g.addEdge(2, 4);
		// the left arial of two ends from here
		g.addEdge(4, 2);
		g.addEdge(3, 4);
		// the left arial of three ends from here
		g.addEdge(4, 3);
		// the left arial of four ends from here
		g.addEdge(1, 5);
		g.addEdge(5, 1);
		g.addEdge(0, 6);
		g.addEdge(6, 0);
		g.addEdge(5, 6);
		// the left arial of six ends from here
		g.addEdge(6, 5);
		g.addEdge(5, 7);
		g.addEdge(7, 5);
		g.addEdge(5, 8);
		// the left arial of five ends from here
		g.addEdge(8, 5);
		g.addEdge(7, 8);
		// the left arial of six ends from here
		g.addEdge(8, 7);
		g.addEdge(8, 9);
		g.addEdge(9, 8);
		g.addEdge(10, 11);
		g.addEdge(11, 10);

		g.BCC();

		System.out.println("Above are edges of" + g.count + "the  biconnected components in graph data structure");
// The main driver code functionality ends from here
	}
}

Output:

4--2 3--4 3--1 2--3 1--2 
8--9 
8--5 7--8 5--7 
6--0 5--6 1--5 0--1 
10--11 Above are five biconnected components in the graph

Python Code

# Here, we are writing down the Python programming language code to 
# demonstrate the concept of Biconnected Components with its relevant code
# and output backed by valid syntax to replicate personalized needs

from collections import defaultdict

# The below class represents a directed graph  using an adjacency list 
class Graph:

	def __init__(self, vertices):
		# the below code snippet shows the no. of vertices
		self.V = vertices
		
	# the below code snippet shows the default dictionary to store graph
		self.graph = defaultdict(list)
		
# the below code snippet shows the time used to find discovery times
		self.Time = 0
		
# the below code snippet shows the count number of biconnected 
# components of the graph data structure
		self.count = 0

# the below class is useful while creating the edges for graph data 
# structure which will be called from the main driver code functionality

	def addEdge(self, u, v):
		self.graph[u].append(v)
		self.graph[v].append(u)

	# function calling the standard BCCU to perform looping over the graph matrix
	def BCCUtil(self, u, parent, low, disc, st):

# the below code snippet helps us in the counting of the children in the current node
		children = 0

# the below code snippet helps us in initializing discovery time and low 
# value
		disc[u] = self.Time
		low[u] = self.Time
		self.Time += 1


# here, we are trying to apply the concept of recursion 
# for all the available vertices that are adjacent to the vertex of the matrix columns deep driven
		for v in self.graph[u]:
		if disc[v] == -1 :
		# assigning the parent of v to the 'u' variable
                               parent[v] = u
                             # incrementing the children's variable count
				children += 1
				st.append((u, v)) # store the edge in stack
				self.BCCUtil(v, parent, low, disc, st)
				low[u] = min(low[u], low[v])
# during the graph matrix data structure traversal, if it is found that u is not a vertex but an 
# articulation point, we need to delete it from the temporary operational stack 
	if parent[u] == -1 and children > 1 or parent[u] != -1 and low[v] >= disc[u]:
                             # incrementing the children's variable count
					self.count += 1 
                                 # the above code snippet increments the count after the conditional check is done
					w = -1
					while w != (u, v):
						w = st.pop()
						print(w,end=" ")
					print()
			
			elif v != parent[u] and low[u] > disc[v]:

				low[u] = min(low [u], disc[v])
	
				st.append((u, v))


	# The function to do DFS traversal. It uses BCCUtil()
	def BCC(self):
		
		# Initialize disc and low, and parent arrays
		disc = [-1] * (self.V)
		low = [-1] * (self.V)
		parent = [-1] * (self.V)
		st = []
		
	# Initialize disc and low, and parent arrays
		for i in range(self.V):
			if disc[i] == -1:
				self.BCCUtil(i, parent, low, disc, st)

# below, we have defined the edge case of the stack to pop all 
# the edges of graph data structure if the stack is found not to be 
# empty

			if st:
				self.count = self.count + 1

				while st:
					w = st.pop()
					print(w,end=" ")
				print ()

# below are the matrix edges of the graph data structure
g = Graph(12)
g.addEdge(0, 1);
g.addEdge(1, 0);
g.addEdge(1, 2);
g.addEdge(2, 1);
g.addEdge(1, 3);
# the left arial of one ends from here
g.addEdge(3, 1);
g.addEdge(2, 3);
g.addEdge(3, 2);
g.addEdge(2, 4);
# the left arial of two ends from here
g.addEdge(4, 2);
g.addEdge(3, 4);
# the left arial of three ends from here
g.addEdge(4, 3);
# the left arial of four ends from here
g.addEdge(1, 5);
g.addEdge(5, 1);
g.addEdge(0, 6);
g.addEdge(6, 0);
g.addEdge(5, 6);
# the left arial of six ends from here
g.addEdge(6, 5);
g.addEdge(5, 7);
g.addEdge(7, 5);
g.addEdge(5, 8);
# the left arial of five ends from here
g.addEdge(8, 5);
g.addEdge(7, 8);
# the left arial of six ends from here
g.addEdge(8, 7);
g.addEdge(8, 9);
g.addEdge(9, 8);
g.addEdge(10, 11);
g.addEdge(11, 10);
g.BCC();
print ("Above are edges of % d the biconnected components in graph data structure" %(g.count));
# The main driver code functionality ends from here

Output:

(4, 2) (3, 4) (3, 1) (2, 3) (1, 2) 
(8, 9) 
(8, 5) (7, 8) (5, 7) 
(6, 0) (5, 6) (1, 5) (0, 1) 
(10, 11) 
Above are the edges of  5 of the biconnected components in the graph data structure.

Next TopicBinary Exponentiation

← prev next →