Open in App
Not now

# Check if adding an edge makes the Undirected Graph cyclic or not

• Last Updated : 14 Mar, 2023

Given an undirected graph, the task is to if adding an edge makes the graph cyclic or not.

In an Undirected graph, a cycle is a path of edges that connects a sequence of vertices back to itself. In other words, a cycle is a closed loop of edges that allows you to traverse the graph and return to the starting vertex.

For example:

A — B
/           \
C            D
\          /
E — F

In this graph, there are several cycles that can be formed by following different sequences of edges. For example, the sequence of edges A-B-D-F-E-C-A forms a cycle, as does the sequence    B-D-F-E-C-A-B.

Naive approach: The basic way to solve the problem is as follows:

Use depth-first Search to detect the cycle during the insertion of the nodes. If while traversing we reach a node that is already visited. This indicates that cycle is formed.

Follow the steps below to solve the problem:

• Create a detect cycle function that takes a graph and a new node as input.
• Define a dfs function that takes a graph, a node, a set of visited nodes, and a search path array as input.
• In the detectCycle function, initialize an empty set of visited nodes and an empty search path array.
• Call the dfs function, starting from the new node, and passing the graph, visited nodes, and search path array as arguments.
• Return the result of the dfs function.
• In the dfs function, mark the current node as visited and add it to the search path array.
• Check all the neighbors of the current node.
• For each neighbor:
• If the neighbor is already visited, check if it is in the current search path.
• If it is, then we have found a cycle, so return true.
• If it is not visited, continue the DFS from that node. If the DFS returns true, then return true as well.
• Remove the current node from the search path array.
• Return false.

Below is the implementation of the above approach:Recommended Practice

Please try your approach on IDE first, before moving on to the solution.

Try It!

## C++

 `//C++ implementation for the above approach` `#include `   `using` `namespace` `std;`   `// Function to traversing over the graph` `bool` `dfs(map<``int``, vector<``int``> > graph, ``int` `node,` `         ``set<``int``> visited, vector<``int``> path)` `{` `    ``// Mark the current node as visited` `    ``visited.insert(node);` `    ``path.push_back(node);`   `    ``// Check if the node has any neighbors` `    ``if` `(graph.count(node) > 0) {` `        ``// Get the list of neighbors` `        ``vector<``int``> neighbors = graph[node];`   `        ``// Check all the neighbors of the` `        ``// current node` `        ``for` `(``int` `neighbor : neighbors) {` `            ``if` `(visited.count(neighbor) > 0) {` `                ``// If the neighbor is already` `                ``// visited, check if it is` `                ``// in the current search path` `                ``if` `(std::find(path.begin(), path.end(),` `                              ``neighbor)` `                    ``!= path.end()) {` `                    ``// If it is, then we have` `                    ``// found a cycle` `                    ``return` `true``;` `                ``}` `            ``}` `            ``else` `{` `                ``// If the neighbor is not` `                ``// visited, continue the DFS` `                ``// from that node` `                ``if` `(dfs(graph, neighbor, visited, path)) {` `                    ``return` `true``;` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Remove the current node from` `    ``// the search path` `    ``path.pop_back();`   `    ``return` `false``;` `}` `// Function to detect cycle is formed` `// by adding an edge` `bool` `detectCycle(map<``int``, vector<``int``> > graph, ``int` `newNode)` `{` `    ``// Perform a DFS starting from the` `    ``// new node` `    ``set<``int``> visited;` `    ``vector<``int``> path;` `    ``bool` `cycleExists = dfs(graph, newNode, visited, path);`   `    ``// Return true, if cycle formed` `    ``return` `cycleExists;` `}`   `int` `main()` `{` `    ``// Test the detectCycle function` `    ``map<``int``, vector<``int``> > graph;` `    ``graph[1] = { 2, 3 };` `    ``graph[2] = { 1, 3 };` `    ``graph[3] = { 1, 2 };`   `    ``// Function call` `    ``if` `(detectCycle(graph, 4)) {` `        ``cout << ``"true"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"false"` `<< endl;` `    ``}`   `    ``// Add a new node to the graph` `    ``// that creates a cycle` `    ``graph[4] = { 1 };`   `    ``if` `(detectCycle(graph, 4)) {` `        ``cout << ``"true"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"false"` `<< endl;` `    ``}`   `    ``return` `0;` `}` `//This code is contributed by Potta Lokesh`

## Java

 `// Java implementation of the above approach` `import` `java.io.*;` `import` `java.util.ArrayList;` `import` `java.util.Arrays;` `import` `java.util.HashMap;` `import` `java.util.HashSet;` `import` `java.util.List;` `import` `java.util.Map;` `import` `java.util.Set;`   `public` `class` `GraphCycleDetector {`   `      ``// Function to detect cycle is formed ` `      ``// by adding an edge` `    ``public` `static` `boolean` `    ``detectCycle(Map > graph,` `                ``int` `newNode)` `    ``{` `      `  `        ``// Perform a DFS starting from the ` `          ``// new node` `        ``Set visited = ``new` `HashSet<>();` `        ``List path = ``new` `ArrayList<>();` `        ``boolean` `cycleExists` `            ``= dfs(graph, newNode, visited, path);` `        `  `          ``// Return true, if cycle formed` `        ``return` `cycleExists;` `      `  `    ``}` `    `  `  `  `      ``// Function to traversing over the graph` `    ``private` `static` `boolean` `    ``dfs(Map > graph, ``int` `node,` `        ``Set visited, List path)` `    ``{` `      `  `        ``// Mark the current node as visited` `        ``visited.add(node);` `        ``path.add(node);`   `        ``// Check if the node has any neighbors` `        ``if` `(graph.containsKey(node)) {` `          `  `            ``// Get the list of neighbors` `            ``List neighbors = graph.get(node);`   `            ``// Check all the neighbors of the ` `              ``// current node` `            ``for` `(``int` `neighbor : neighbors) {` `              `  `                ``if` `(visited.contains(neighbor)) {` `                  `  `                    ``// If the neighbor is already` `                    ``// visited, check if it is ` `                    ``// in the current search path` `                    ``if` `(path.contains(neighbor)) {` `                      `  `                        ``// If it is, then we have ` `                        ``// found a cycle` `                        ``return` `true``;` `                    ``}` `                ``}` `                ``else` `{` `                    ``// If the neighbor is not ` `                    ``// visited, continue the DFS ` `                      ``// from that node` `                    ``if` `(dfs(graph, neighbor, visited,` `                            ``path)) {` `                        ``return` `true``;` `                    ``}` `                ``}` `            ``}` `        ``}`   `        ``// Remove the current node from ` `          ``// the search path` `        ``path.remove(path.size() - ``1``);`   `        ``return` `false``;` `    ``}` `    `  `      ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Test the detectCycle function` `        ``Map > graph` `            ``= ``new` `HashMap<>();` `        ``graph.put(``1``, Arrays.asList(``2``, ``3``));` `        ``graph.put(``2``, Arrays.asList(``1``, ``3``));` `        ``graph.put(``3``, Arrays.asList(``1``, ``2``));` `    `  `          ``// Function call` `        ``System.out.println(` `            ``detectCycle(graph, ``4``)); `   `        ``// Add a new node to the graph ` `          ``// that creates a cycle` `        ``graph.put(``4``, Arrays.asList(``1``));`   `        ``System.out.println(` `            ``detectCycle(graph, ``4``));` `    ``}` `}`

## Python3

 `# Python3 implementation of the above approach` `from` `collections ``import` `defaultdict`   `# Function to traversing over the graph` `def` `dfs(graph, node, visited, path):` `    ``# Mark the current node as visited` `    ``visited.add(node)` `    ``path.append(node)`   `    ``# Check if the node has any neighbors` `    ``if` `node ``in` `graph:` `        ``# Get the list of neighbors` `        ``neighbors ``=` `graph[node]`   `        ``# Check all the neighbors of the` `        ``# current node` `        ``for` `neighbor ``in` `neighbors:` `            ``if` `neighbor ``in` `visited:` `                ``# If the neighbor is already` `                ``# visited, check if it is` `                ``# in the current search path` `                ``if` `neighbor ``in` `path:` `                    ``# If it is, then we have` `                    ``# found a cycle` `                    ``return` `True` `            ``else``:` `                ``# If the neighbor is not` `                ``# visited, continue the DFS` `                ``# from that node` `                ``if` `dfs(graph, neighbor, visited, path):` `                    ``return` `True`   `    ``# Remove the current node from` `    ``# the search path` `    ``path.pop()`   `    ``return` `False`   `# Function to detect cycle is formed` `# by adding an edge` `def` `detect_cycle(graph, new_node):` `    ``# Perform a DFS starting from the` `    ``# new node` `    ``visited ``=` `set``()` `    ``path ``=` `[]` `    ``cycle_exists ``=` `dfs(graph, new_node, visited, path)`   `    ``# Return true, if cycle formed` `    ``return` `cycle_exists`   `# Test the detect_cycle function` `graph ``=` `defaultdict(``list``)` `graph[``1``] ``=` `[``2``, ``3``]` `graph[``2``] ``=` `[``1``, ``3``]` `graph[``3``] ``=` `[``1``, ``2``]`   `# Function call` `if` `detect_cycle(graph, ``4``):` `    ``print``(``"true"``)` `else``:` `    ``print``(``"false"``)`   `# Add a new node to the graph` `# that creates a cycle` `graph[``4``] ``=` `[``1``]`   `if` `detect_cycle(graph, ``4``):` `    ``print``(``"true"``)` `else``:` `    ``print``(``"false"``)` `    `  `    ``# This code is contributed by poojaagarwal2.`

## C#

 `// C# code implementation for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Function to detect cycle is formed by adding an edge` `  ``public` `static` `bool` `    ``DetectCycle(Dictionary<``int``, List<``int``> > graph,` `                ``int` `newNode)` `  ``{` `    ``// Perform a DFS starting from the new node` `    ``var` `visited = ``new` `HashSet<``int``>();` `    ``var` `path = ``new` `List<``int``>();` `    ``var` `cycleExists` `      ``= Dfs(graph, newNode, visited, path);`   `    ``// Return true, if cycle formed` `    ``return` `cycleExists;` `  ``}`   `  ``// Function to traversing over the graph` `  ``private` `static` `bool` `    ``Dfs(Dictionary<``int``, List<``int``> > graph, ``int` `node,` `        ``HashSet<``int``> visited, List<``int``> path)` `  ``{` `    ``// Mark the current node as visited` `    ``visited.Add(node);` `    ``path.Add(node);`   `    ``// Check if the node has any neighbors` `    ``if` `(graph.ContainsKey(node)) {` `      ``// Get the list of neighbors` `      ``var` `neighbors = graph[node];`   `      ``// Check all the neighbors of the current node` `      ``foreach``(``var` `neighbor ``in` `neighbors)` `      ``{` `        ``if` `(visited.Contains(neighbor)) {` `          ``// If the neighbor is already visited,` `          ``// check if it is in the current search` `          ``// path` `          ``if` `(path.Contains(neighbor)) {` `            ``// If it is, then we have found a` `            ``// cycle` `            ``return` `true``;` `          ``}` `        ``}` `        ``else` `{` `          ``// If the neighbor is not visited,` `          ``// continue the DFS from that node` `          ``if` `(Dfs(graph, neighbor, visited,` `                  ``path)) {` `            ``return` `true``;` `          ``}` `        ``}` `      ``}` `    ``}`   `    ``// Remove the current node from the search path` `    ``path.RemoveAt(path.Count - 1);`   `    ``return` `false``;` `  ``}`   `  ``static` `public` `void` `Main()` `  ``{`   `    ``// Code` `    ``// Test the DetectCycle function` `    ``var` `graph = ``new` `Dictionary<``int``, List<``int``> >{` `      ``{ 1, ``new` `List<``int``>{ 2, 3 } },` `      ``{ 2, ``new` `List<``int``>{ 1, 3 } },` `      ``{ 3, ``new` `List<``int``>{ 1, 2 } }` `    ``};`   `    ``// Function call` `    ``Console.WriteLine(DetectCycle(graph, 4));`   `    ``// Add a new node to the graph that creates a cycle` `    ``graph.Add(4, ``new` `List<``int``>{ 1 });`   `    ``Console.WriteLine(DetectCycle(graph, 4));` `  ``}` `}`   `// This code is contributed by sankar.`

## Javascript

 `function` `detectCycle(graph, newNode) {` `  ``// Perform a DFS starting from the new node` `  ``let visited = ``new` `Set()` `  ``let path = []` `  ``let cycleExists = dfs(graph, newNode, visited, path)`   `  ``return` `cycleExists` `}`   `function` `dfs(graph, node, visited, path) {` `  ``// Mark the current node as visited` `  ``visited.add(node)` `  ``path.push(node)`   `  ``// Check if the node has any neighbors` `  ``if` `(graph[node]) {` `    ``// Convert the neighbors to an array if necessary` `    ``let neighbors = Array.isArray(graph[node]) ? graph[node] : [graph[node]]`   `    ``// Check all the neighbors of the current node` `    ``for` `(let neighbor of neighbors) {` `      ``if` `(visited.has(neighbor)) {` `        ``// If the neighbor is already visited, check if it is in the current search path` `        ``if` `(path.includes(neighbor)) {` `          ``// If it is, then we have found a cycle` `          ``return` `true` `        ``}` `      ``} ``else` `{` `        ``// If the neighbor is not visited, continue the DFS from that node` `        ``if` `(dfs(graph, neighbor, visited, path)) {` `          ``return` `true` `        ``}` `      ``}` `    ``}` `  ``}`   `  ``// Remove the current node from the search path` `  ``path.pop()`   `  ``return` `false` `}` `// Test the detectCycle function` `let graph = {` `  ``1: [2, 3],` `  ``2: [1, 3],` `  ``3: [1, 2],` `}`   `console.log(detectCycle(graph, 4)) ``// should print false`   `// Add a new node to the graph that creates a cycle` `graph[4] = [1]`   `console.log(detectCycle(graph, 4)) ``// should print true`

Output

```false
true```

Time complexity:  O(V+E), where V is the number of vertices (or nodes) in the graph, and E is the number of edges in the graph.
Auxiliary Space:  O(V)

Efficient Approach: The above approach can be optimized based on the following idea:

• The approach used in the above code is a union-find-based approach to detect cycles in the graph.
• The find() method is used to find the root of the tree representing a given node, and
• the addEdge() method uses the find() method to find the roots of the trees representing the two nodes being connected by the edge.
• If the roots are the same, it means that the two nodes are already in the same connected component, and adding the edge would create a cycle in the graph.
• If the roots are different, the addEdge() method merges the two connected components by attaching the root of the smaller tree to the root of the larger tree.

Below is the implementation of the above approach:

## C++

 `#include ` `#include `   `using` `namespace` `std;`   `class` `Graph {` `    ``private``:` `        ``int` `V; ``// Number of vertices in the graph` `        ``vector > adj; ``// Vector of vectors to store the adjacency list of each vertex` `        ``int` `*parent; ``// Array to store the parent of each vertex in the disjoint set` `        ``int` `*rank; ``// Array to store the rank of each vertex in the disjoint set`   `    ``public``:` `        ``Graph(``int` `V) {` `            ``this``->V = V; ``// Set the number of vertices in the graph` `            ``adj.resize(V); ``// Resize the adjacency list to accommodate V vertices` `            ``parent = ``new` `int``[V]; ``// Allocate memory for the parent array` `            ``rank = ``new` `int``[V]; ``// Allocate memory for the rank array` `            ``for` `(``int` `i = 0; i < V; i++) {` `                ``parent[i] = i; ``// Set the initial parent of each vertex to itself` `                ``rank[i] = 0; ``// Set the initial rank of each vertex to 0` `            ``}` `        ``}`   `        ``bool` `addEdge(``int` `u, ``int` `v) {` `            ``int` `rootU = find(u); ``// Find the root of the disjoint set containing vertex u` `            ``int` `rootV = find(v); ``// Find the root of the disjoint set containing vertex v` `            ``if` `(rootU == rootV) { ``// If u and v are already in the same disjoint set, there is no need to add the edge` `                ``return` `false``; ``// Return false to indicate that the edge was not added` `            ``}` `            ``if` `(rank[rootU] < rank[rootV]) { ``// If the rank of the disjoint set containing u is less than the rank of the disjoint set containing v` `                ``parent[rootU] = rootV; ``// Make v the parent of u` `            ``}` `            ``else` `if` `(rank[rootU] > rank[rootV]) { ``// If the rank of the disjoint set containing u is greater than the rank of the disjoint set containing v` `                ``parent[rootV] = rootU; ``// Make u the parent of v` `            ``}` `            ``else` `{ ``// If the rank of the disjoint set containing u is equal to the rank of the disjoint set containing v` `                ``parent[rootV] = rootU; ``// Make u the parent of v` `                ``rank[rootU]++; ``// Increment the rank of the disjoint set containing u` `            ``}` `            ``adj[u].push_back(v); ``// Add v to the adjacency list of u` `            ``adj[v].push_back(u); ``// Add u to the adjacency list of v` `            ``return` `true``; ``// Return true to indicate that the edge was added` `        ``}`   `        ``int` `find(``int` `u) {` `            ``if` `(parent[u] != u) { ``// If the parent of u is not u, i.e., u is not the root of its disjoint set` `                ``parent[u] = find(parent[u]); ``// Recursively find the root of the disjoint set containing u and update the parent of u to point directly to the root` `            ``}` `            ``return` `parent[u]; ``// Return the root of the disjoint set containing u` `        ``}` `};`   `// driver code ` `// Create a graph with 4 vertices` `int` `main() {` `    ``Graph graph(4);` `    ``graph.addEdge(0, 1);` `    ``graph.addEdge(0, 2);` `    ``graph.addEdge(1, 2);` `    ``if` `(graph.addEdge(2, 3)) {` `        ``cout << ``"false"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"true"` `<< endl;` `    ``}` `    ``if` `(graph.addEdge(3, 0)) {` `        ``cout << ``"false"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"true"` `<< endl;` `    ``}` `    ``return` `0;` `}` `// this code is contributed by devendrasalunke `

## Java

 `// Java Implementation of the above approach` `import` `java.io.*;` `import` `java.util.ArrayList;` `import` `java.util.List;`   `public` `class` `Graph {` `    ``private` `final` `int` `V;` `    ``private` `final` `List > adj;` `    ``private` `final` `int``[] parent;` `    ``private` `final` `int``[] rank;`   `    ``// Function to create Graph` `    ``public` `Graph(``int` `V)` `    ``{`   `        ``this``.V = V;` `        ``adj = ``new` `ArrayList<>(V);` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``adj.add(``new` `ArrayList<>());` `        ``}` `        ``parent = ``new` `int``[V];` `        ``rank = ``new` `int``[V];` `        ``for` `(``int` `i = ``0``; i < V; i++) {` `            ``parent[i] = i;` `            ``rank[i] = ``0``;` `        ``}` `    ``}`   `    ``// Function to add edge in graph` `    ``public` `boolean` `addEdge(``int` `u, ``int` `v)` `    ``{` `        ``// Find the roots of the trees` `        ``// representing u and v` `        ``int` `rootU = find(u);` `        ``int` `rootV = find(v);` `        ``if` `(rootU == rootV) {` `            ``// If the roots are the same,` `            ``// then u and v are already in the` `            ``// same connected component, so` `            ``// adding the edge (u, v) would create a cycle` `            ``return` `false``;` `        ``}` `        ``// If the roots are different, merge` `        ``// the two connected components by` `        ``// attaching the root of the smaller tree` `        ``// to the root of the larger tree` `        ``if` `(rank[rootU] < rank[rootV]) {`   `            ``parent[rootU] = rootV;` `        ``}` `        ``else` `if` `(rank[rootU] > rank[rootV]) {` `            ``parent[rootV] = rootU;` `        ``}` `        ``else` `{` `            ``parent[rootV] = rootU;` `            ``rank[rootU]++;` `        ``}` `        ``// Add the edge (u, v) to the adjacency` `        ``// list` `        ``adj.get(u).add(v);` `        ``adj.get(v).add(u);` `        ``return` `true``;` `    ``}`   `    ``private` `int` `find(``int` `u)` `    ``{` `        ``// Find the root of the tree` `        ``// representing u` `        ``if` `(parent[u] != u) {`   `            ``parent[u] = find(parent[u]);` `        ``}` `        ``return` `parent[u];` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``Graph graph = ``new` `Graph(``4``);` `        ``graph.addEdge(``0``, ``1``);` `        ``graph.addEdge(``0``, ``2``);` `        ``graph.addEdge(``1``, ``2``);` `        ``// graph.addEdge(2, 3);`   `        ``if` `(graph.addEdge(``2``, ``3``)) {` `            ``// adding edge(2,3) would not ` `              ``// create a cycle` `            ``System.out.println(``"false"``);` `        ``}` `        ``else` `{` `            ``// adding edge (2, 3) would ` `              ``// create a cycle` `            ``System.out.println(``"true"``);` `        ``}`   `        ``if` `(graph.addEdge(``3``, ``0``)) {` `            ``// adding edge(3,0) would not ` `              ``// create a cycle` `            ``System.out.println(``"false"``);` `        ``}` `        ``else` `{` `            ``// adding edge (3, 0) would ` `              ``// create a cycle` `            ``System.out.println(``"true"``);` `        ``}` `    ``}` `}`

## Javascript

 `// Define a class called Graph` `class Graph {` `    ``// Constructor takes in number of vertices and initializes necessary properties` `    ``constructor(V) {` `        ``// Store the number of vertices` `        ``this``.V = V;` `        ``// Create an array of arrays to store the adjacency list` `        ``this``.adj = ``new` `Array(V);` `        ``// Initialize each adjacency list to be empty` `        ``for` `(let i = 0; i < V; i++) {` `            ``this``.adj[i] = [];` `        ``}` `        ``// Initialize the parent array for each vertex to be itself` `        ``this``.parent = ``new` `Array(V);` `        ``for` `(let i = 0; i < V; i++) {` `            ``this``.parent[i] = i;` `        ``}` `        ``// Initialize the rank array for each vertex to be 0` `        ``this``.rank = ``new` `Array(V);` `        ``for` `(let i = 0; i < V; i++) {` `            ``this``.rank[i] = 0;` `        ``}` `    ``}`   `    ``// Method to add an undirected edge between two vertices` `    ``addEdge(u, v) {` `        ``// Find the root of the set that u belongs to` `        ``let rootU = ``this``.find(u);` `        ``// Find the root of the set that v belongs to` `        ``let rootV = ``this``.find(v);` `        ``// If both vertices belong to the same set, then adding an edge between them will create a cycle` `        ``if` `(rootU === rootV) {` `            ``// Return false to indicate that the edge was not added` `            ``return` `false``;` `        ``}` `        ``// If the rank of the set that u belongs to is smaller than the rank of the set that v belongs to` `        ``if` `(``this``.rank[rootU] < ``this``.rank[rootV]) {` `            ``// Set the parent of u's root to be v's root` `            ``this``.parent[rootU] = rootV;` `        ``}` `        ``// If the rank of the set that v belongs to is smaller than the rank of the set that u belongs to` `        ``else` `if` `(``this``.rank[rootU] > ``this``.rank[rootV]) {` `            ``// Set the parent of v's root to be u's root` `            ``this``.parent[rootV] = rootU;` `        ``}` `        ``// If the ranks of the sets that u and v belong to are the same` `        ``else` `{` `            ``// Set the parent of v's root to be u's root` `            ``this``.parent[rootV] = rootU;` `            ``// Increment the rank of the set that u belongs to by 1` `            ``this``.rank[rootU]++;` `        ``}` `        ``// Add v to u's adjacency list` `        ``this``.adj[u].push(v);` `        ``// Add u to v's adjacency list` `        ``this``.adj[v].push(u);` `        ``// Return true to indicate that the edge was added` `        ``return` `true``;` `    ``}`   `    ``// Method to find the root of the set that a vertex belongs to` `    ``find(u) {` `        ``// If the parent of u is not itself (i.e. u is not the root of its set)` `        ``if` `(``this``.parent[u] !== u) {` `            ``// Recursively find the root of the set that u belongs to` `            ``this``.parent[u] = ``this``.find(``this``.parent[u]);` `        ``}` `        ``// Return the root of the set that u belongs to` `        ``return` `this``.parent[u];` `    ``}` `}`   `// Create a new graph with 4 vertices` `let graph = ``new` `Graph(4);` `// Add edges between vertices` `graph.addEdge(0, 1);` `graph.addEdge(0, 2);` `graph.addEdge(1, 2);`   `// Try to add an edge between vertices that already belong to the same set` `if` `(graph.addEdge(2, 3)) {` `    ``console.log(``"false"``);` `}` `else` `{` `    ``console.log(``"true"``);` `}`   `if` `(graph.addEdge(3, 0)) {` `    ``console.log(``"false"``);` `}` `else` `{` `    ``console.log(``"true"``);` `}`

## C#

 `// C# Implementation of the above approach`   `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `Graph {`   `    ``private` `List > adj;` `    ``private` `int``[] parent;` `    ``private` `int``[] rank;`   `    ``// Function to create Graph` `    ``public` `Graph(``int` `V)` `    ``{`   `        ``adj = ``new` `List >(V);` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``adj.Add(``new` `List<``int``>());` `        ``}` `        ``parent = ``new` `int``[V];` `        ``rank = ``new` `int``[V];` `        ``for` `(``int` `i = 0; i < V; i++) {` `            ``parent[i] = i;` `            ``rank[i] = 0;` `        ``}` `    ``}`   `    ``// Function to add edge in graph` `    ``public` `bool` `AddEdge(``int` `u, ``int` `v)` `    ``{` `        ``// Find the roots of the trees representing u and v` `        ``int` `rootU = Find(u);` `        ``int` `rootV = Find(v);` `        ``if` `(rootU == rootV) {` `            ``// If the roots are the same, then u and v are` `            ``// already in the same connected component, so` `            ``// adding the edge (u, v) would create a cycle` `            ``return` `false``;` `        ``}` `        ``// If the roots are different, merge the two` `        ``// connected components by attaching the root of the` `        ``// smaller tree to the root of the larger tree` `        ``if` `(rank[rootU] < rank[rootV]) {`   `            ``parent[rootU] = rootV;` `        ``}` `        ``else` `if` `(rank[rootU] > rank[rootV]) {` `            ``parent[rootV] = rootU;` `        ``}` `        ``else` `{` `            ``parent[rootV] = rootU;` `            ``rank[rootU]++;` `        ``}` `        ``// Add the edge (u, v) to the adjacency list` `        ``adj[u].Add(v);` `        ``adj[v].Add(u);` `        ``return` `true``;` `    ``}`   `    ``private` `int` `Find(``int` `u)` `    ``{` `        ``// Find the root of the tree representing u` `        ``if` `(parent[u] != u) {`   `            ``parent[u] = Find(parent[u]);` `        ``}` `        ``return` `parent[u];` `    ``}`   `    ``static` `public` `void` `Main()` `    ``{`   `        ``// Code` `        ``Graph graph = ``new` `Graph(4);` `        ``graph.AddEdge(0, 1);` `        ``graph.AddEdge(0, 2);` `        ``graph.AddEdge(1, 2);` `        ``// graph.AddEdge(2, 3);`   `        ``if` `(graph.AddEdge(2, 3)) {` `            ``// adding edge(2,3) would not create a cycle` `            ``Console.WriteLine(``"false"``);` `        ``}` `        ``else` `{` `            ``// adding edge (2, 3) would create a cycle` `            ``Console.WriteLine(``"true"``);` `        ``}`   `        ``if` `(graph.AddEdge(3, 0)) {` `            ``// adding edge(3,0) would not create a cycle` `            ``Console.WriteLine(``"false"``);` `        ``}` `        ``else` `{` `            ``// adding edge (3, 0) would create a cycle` `            ``Console.WriteLine(``"true"``);` `        ``}` `    ``}` `}`   `// This code is contributed by karthik.`

Output

```false
true```

Time complexity: O(E log V)
Auxiliary Space: O(V)

My Personal Notes arrow_drop_up
Related Articles