# Check if a given Graph is 2-edge connected or not

Given an undirected graph G, with V vertices and E edges, the task is to check whether the graph is 2-edge connected or not.

A graph is said to be 2-edge connected if, on removing any edge of the graph, it still remains connected, i.e. it contains no Bridges

Examples:

Input: V = 8, E = 10

Output: Yes
Explanation:
Given any vertex in the graph, we can reach any other vertex in the graph. Moreover, removing any edge from the graph does not affect its connectivity. So, the graph is said to be 2-edge connected.

Input: V = 8, E = 9

Output: No
Explanation:
On removal of the edge between vertex 3 and vertex 4, the graph is not connected anymore. So, the graph is not 2-edge connected.

Naive Approach: The naive approach is to check that on removing any edge X, if the remaining graph G – X is connected or not. If the graph remains connected on removing every edge one by one then it is a 2-edge connected graph. To implement the above idea, remove an edge and perform Depth First Search(DFS) or Breadth-First Search(BFS) from any vertex and check if all vertices are covered or not. Repeat this process for all E edges. If all vertices cannot be traversed for any edge, print No. Otherwise, print Yes

Time Complexity: O(E * ( V + E))
Auxiliary Space: O(1)

Efficient Approach: Since the given graph is undirected, the problem can be solved only by counting the number of edges connected to the nodes. If for any of the nodes, the number of edges connected to it is 1 it means on removing this edge the node becomes disconnected and it can’t be reached from any other node therefore the graph is not 2-edge connected. Below are the steps:

1. Create an array noOfEdges[] of size V which will store the number of edges connected to a node.
2. For every edge (u, v) increment the number of edges for node u and v.
3. Now iterate over the array noOfEdges[] and check if any of the edge has only 1 edge connected to it. If yes then the graph is not 2-edge connected.
4. Otherwise, the graph is 2-edge connected.

Below is the implementation of the above approach:

 `// C++14 program for the above approach`   `#include ` `using` `namespace` `std;`   `// Definition of a graph` `class` `Graph {`   `    ``// No. of vertices` `    ``int` `V;`   `    ``// To create adjacency list` `    ``list<``int``>* adj;`   `public``:` `    ``// Constructor` `    ``Graph(``int` `V);`   `    ``// Function to add an edge to graph` `    ``void` `addEdge(``int` `v, ``int` `w);`   `    ``// Function to check 2-edge` `    ``// 2-edge connectivity` `    ``void` `twoEdge(``int` `v);` `};`   `// Initialize the graph` `Graph::Graph(``int` `V)` `{` `    ``this``->V = V;` `    ``adj = ``new` `list<``int``>[V];` `}`   `// Adding edges to adjacency list` `void` `Graph::addEdge(``int` `v, ``int` `w)` `{` `    ``adj[v - 1].push_back(w - 1);` `    ``adj[w - 1].push_back(v - 1);` `}`   `// Function to find if the graph is` `// 2 edge connected or not` `void` `Graph::twoEdge(``int` `v)` `{` `    ``// To store number of edges for` `    ``// each node` `    ``int` `noOfEdges[v];`   `    ``for` `(``int` `i = 0; i < v; i++) {` `        ``noOfEdges[i] = adj[i].size();` `    ``}`   `    ``bool` `flag = ``true``;`   `    ``// Check the number of edges` `    ``// connected to each node` `    ``for` `(``int` `i = 0; i < v; i++) {`   `        ``if` `(noOfEdges[i] < 2) {` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}`   `    ``// Print the result` `    ``if` `(flag)` `        ``cout << ``"Yes"``;` `    ``else` `        ``cout << ``"No"``;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Number of nodes and edges` `    ``int` `V = 8;` `    ``int` `E = 10;`   `    ``// Given Edges` `    ``int` `edges[E] = { { 1, 2 }, { 1, 8 }, { 1, 6 }, ` `                        ``{ 2, 3 }, { 2, 4 }, { 3, 7 }, ` `                        ``{ 3, 4 }, { 7, 5 }, { 7, 6 }, ` `                        ``{ 7, 8 } };`   `    ``// Initialize the graph` `    ``Graph g(V);`   `    ``// Adding the edges to graph` `    ``for` `(``int` `i = 0; i < E; i++) {` `        ``g.addEdge(edges[i], edges[i]);` `    ``}`   `    ``// Function call` `    ``g.twoEdge(V);`   `    ``return` `0;` `}`

 `// Java program for the above approach` `import` `java.util.*;`   `class` `Graph{` `    `  `// No. of vertices     ` `private` `int` `V; `   `// Array of lists for Adjacency` `// List Representation ` `private` `LinkedList adj[]; `   `// Constructor ` `@SuppressWarnings``(``"unchecked"``)` `Graph(``int` `v) ` `{ ` `    ``V = v; ` `    ``adj = ``new` `LinkedList[v];` `    `  `    ``for``(``int` `i = ``0``; i < v; ++i) ` `        ``adj[i] = ``new` `LinkedList(); ` `} `   `// Function to add an edge into the graph ` `void` `addEdge(``int` `v, ``int` `w) ` `{ ` `    ``adj[v - ``1``].add(w - ``1``); ``// Add w to v's list. ` `    ``adj[w - ``1``].add(v - ``1``);` `} `   `// Function to find if the graph is` `// 2 edge connected or not` `void` `twoEdge(``int` `v)` `{` `    `  `    ``// To store number of edges for` `    ``// each node` `    ``int``[] noOfEdges = ``new` `int``[v];` `    ``for``(``int` `i = ``0``; i < v; i++) ` `    ``{` `        ``noOfEdges[i] = adj[i].size();` `    ``}`   `    ``boolean` `flag = ``true``;` `    `  `    ``// Check the number of edges` `    ``// connected to each node` `    ``for``(``int` `i = ``0``; i < v; i++)` `    ``{` `        ``if` `(noOfEdges[i] < ``2``)` `        ``{` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}` `    `  `    ``// Print the result` `    ``if` `(flag)` `        ``System.out.print(``"Yes"``);` `    ``else` `        ``System.out.print(``"No"``);` `}`   `// Driver code` `public` `static` `void` `main (String[] args) ` `{` `    `  `    ``// Number of nodes and edges` `    ``int` `V = ``8``;` `    ``int` `E = ``10``;` `    `  `    ``// Given Edges` `    ``int` `edges[][] = { { ``1``, ``2` `}, { ``1``, ``8` `},` `                      ``{ ``1``, ``6` `}, { ``2``, ``3` `},` `                      ``{ ``2``, ``4` `}, { ``3``, ``7` `}, ` `                      ``{ ``3``, ``4` `}, { ``7``, ``5` `}, ` `                      ``{ ``7``, ``6` `}, { ``7``, ``8` `} };` `    `  `    ``Graph g = ``new` `Graph(V); ` `    `  `    ``// Adding the edges to graph` `    ``for``(``int` `i = ``0``; i < E; i++) ` `    ``{` `        ``g.addEdge(edges[i][``0``], edges[i][``1``]);` `    ``}` `    `  `    ``// Function call` `    ``g.twoEdge(V);` `}` `}`   `// This code is contributed by offbeat`

 `# Python3 program for the above approach`   `# Definition of a graph` `class` `Graph:`   `    ``# No. of vertices` `    ``V ``=` `0`   `    ``# Array of lists for Adjacency` `    ``# List Representation` `    ``adj ``=` `[[]]`   `    ``# Constructor` `    ``def` `__init__(``self``, v):` `        `  `        ``self``.V ``=` `v` `        ``self``.adj ``=` `[[] ``for` `i ``in` `range``(v)]`   `    ``# Function to add an edge into the graph` `    ``def` `addEdge(``self``, v, w):` `    `  `        ``self``.adj[v ``-` `1``].append(w ``-` `1``)` `        `  `        ``# Add w to v's list.` `        ``self``.adj[w ``-` `1``].append(v ``-` `1``)`   `    ``# Function to find if the graph is` `    ``# 2 edge connected or not` `    ``def` `twoEdge(``self``, v):`   `        ``# To store number of edges for` `        ``# each node` `        ``noOfEdges ``=` `[``len``(``self``.adj[i]) ``for` `i ``in` `range``(v)]`   `        ``flag ``=` `True`   `        ``# Check the number of edges` `        ``# connected to each node` `        ``for` `i ``in` `range``(v):` `            ``if` `(noOfEdges[i] < ``2``):` `                ``flag ``=` `False` `                ``break` `            `  `        ``# Print the result` `        ``if` `(flag):` `            ``print``(``"Yes"``)` `        ``else``:` `            ``print``(``"No"``)` `    `  `# Driver code` `if` `__name__``=``=``"__main__"``:`   `    ``# Number of nodes and edges` `    ``V ``=` `8` `    ``E ``=` `10`   `    ``# Given Edges` `    ``edges ``=` `[ [ ``1``, ``2` `], [ ``1``, ``8` `], ` `              ``[ ``1``, ``6` `], [ ``2``, ``3` `],` `              ``[ ``2``, ``4` `], [ ``3``, ``7` `],` `              ``[ ``3``, ``4` `], [ ``7``, ``5` `],` `              ``[ ``7``, ``6` `], [ ``7``, ``8` `] ]`   `    ``g ``=` `Graph(V)`   `    ``# Adding the edges to graph` `    ``for` `i ``in` `range``(E):` `        ``g.addEdge(edges[i][``0``],` `                  ``edges[i][``1``])` `    `  `    ``# Function call` `    ``g.twoEdge(V)`   `# This code is contributed by rutvik_56`

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `Graph{` `    `  `// No. of vertices     ` `private` `int` `V; `   `// Array of lists for Adjacency` `// List Representation ` `private` `List<``int``> []adj; `   `// Constructor ` `Graph(``int` `v) ` `{ ` `    ``V = v; ` `    ``adj = ``new` `List<``int``>[v];` `    `  `    ``for``(``int` `i = 0; i < v; ++i) ` `        ``adj[i] = ``new` `List<``int``>(); ` `} `   `// Function to add an edge into the graph ` `void` `addEdge(``int` `v, ``int` `w) ` `{ ` `    `  `    ``// Add w to v's list. ` `    ``adj[v - 1].Add(w - 1); ` `    ``adj[w - 1].Add(v - 1);` `} `   `// Function to find if the graph is` `// 2 edge connected or not` `void` `twoEdge(``int` `v)` `{` `    `  `    ``// To store number of edges for` `    ``// each node` `    ``int``[] noOfEdges = ``new` `int``[v];` `    ``for``(``int` `i = 0; i < v; i++) ` `    ``{` `        ``noOfEdges[i] = adj[i].Count;` `    ``}`   `    ``bool` `flag = ``true``;` `    `  `    ``// Check the number of edges` `    ``// connected to each node` `    ``for``(``int` `i = 0; i < v; i++)` `    ``{` `        ``if` `(noOfEdges[i] < 2)` `        ``{` `            ``flag = ``false``;` `            ``break``;` `        ``}` `    ``}` `    `  `    ``// Print the result` `    ``if` `(flag)` `        ``Console.Write(``"Yes"``);` `    ``else` `        ``Console.Write(``"No"``);` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `    `  `    ``// Number of nodes and edges` `    ``int` `V = 8;` `    ``int` `E = 10;` `    `  `    ``// Given Edges` `    ``int` `[,]edges = { { 1, 2 }, { 1, 8 },` `                     ``{ 1, 6 }, { 2, 3 },` `                     ``{ 2, 4 }, { 3, 7 }, ` `                     ``{ 3, 4 }, { 7, 5 }, ` `                     ``{ 7, 6 }, { 7, 8 } };` `    `  `    ``Graph g = ``new` `Graph(V); ` `    `  `    ``// Adding the edges to graph` `    ``for``(``int` `i = 0; i < E; i++) ` `    ``{` `        ``g.addEdge(edges[i, 0], edges[i, 1]);` `    ``}` `    `  `    ``// Function call` `    ``g.twoEdge(V);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:
```No

```

Time Complexity: O(V + E)
Auxiliary Space: O(V)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Article Tags :