Breaking News: Grepper is joining You.com. Read the official announcement!

Detect cycle in an undirected graph

Add Answer

subham answered on January 25, 2022 Popularity 10/10 Helpfulness 3/10

answer Detect cycle in an undirected graph

related Detect cycle in an undirected graph

related Detect cycle in an undirected graph python

Detect cycle in an undirected graph

Comment

//function snippet using DFS
bool dfs(int node,int parent, vector<int> adj[], vector<bool> &check)
    {
        check[node] = true;
        for(auto n1 :adj[node])
        {
            if(!check[n1])
                if(dfs(n1, node, adj, check)) return true;
            else if(n1 != parent) return true;
        }
        return false;
    }
    
    bool isCycle(int V, vector<int> adj[]) {
        vector<bool>check(V, 0);
        //for all the commponents 
        for(int i =0; i < V; i++)
        {
            if(!check[i])
                if (dfs(i, -1, adj, check)) return true;// if a component has a cycle then graph has a cycle 
        }
        return false;
    }

Popularity 10/10 Helpfulness 3/10 Language cpp

Source: Grepper

Tags: c++ cycle detect undirected-graph

Link to this answer
Share Copy Link

Contributed on Jan 25 2022

subham

0 Answers Avg Quality 2/10

Closely Related Answers

Detect cycle in an undirected graph

Comment

// A Java Program to detect cycle in an undirected graph
import java.io.*;
import java.util.*;
// This class represents a
// directed graph using adjacency list
// representation
class Graph {
 
    // No. of vertices
    private int V;
 
    // Adjacency List Representation
    private LinkedList<Integer> adj[];
 
    // Constructor
    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].add(w);
        adj[w].add(v);
    }
 
    // A recursive function that
    // uses visited[] and parent to detect
    // cycle in subgraph reachable
    // from vertex v.
    Boolean isCyclicUtil(int v, Boolean visited[],
                         int parent)
    {
        // Mark the current node as visited
        visited[v] = true;
        Integer i;
 
        // Recur for all the vertices
        // adjacent to this vertex
        Iterator<Integer> it = adj[v].iterator();
        while (it.hasNext()) {
            i = it.next();
 
            // If an adjacent is not
            // visited, then recur for that
            // adjacent
            if (!visited[i]) {
                if (isCyclicUtil(i, visited, v))
                    return true;
            }
 
            // If an adjacent is visited
            // and not parent of current
            // vertex, then there is a cycle.
            else if (i != parent)
                return true;
        }
        return false;
    }
 
    // Returns true if the graph
    // contains a cycle, else false.
    Boolean isCyclic()
    {
 
        // Mark all the vertices as
        // not visited and not part of
        // recursion stack
        Boolean visited[] = new Boolean[V];
        for (int i = 0; i < V; i++)
            visited[i] = false;
 
        // Call the recursive helper
        // function to detect cycle in
        // different DFS trees
        for (int u = 0; u < V; u++) {
 
            // Don't recur for u if already visited
            if (!visited[u])
                if (isCyclicUtil(u, visited, -1))
                    return true;
        }
 
        return false;
    }
 
    // Driver method to test above methods
    public static void main(String args[])
    {
 
        // Create a graph given
        // in the above diagram
        Graph g1 = new Graph(5);
        g1.addEdge(1, 0);
        g1.addEdge(0, 2);
        g1.addEdge(2, 1);
        g1.addEdge(0, 3);
        g1.addEdge(3, 4);
        if (g1.isCyclic())
            System.out.println("Graph
                             contains cycle");
        else
            System.out.println("Graph
                        doesn't contains cycle");
 
        Graph g2 = new Graph(3);
        g2.addEdge(0, 1);
        g2.addEdge(1, 2);
        if (g2.isCyclic())
            System.out.println("Graph
                             contains cycle");
        else
            System.out.println("Graph
                        doesn't contains cycle");
    }
}
// This code is contributed by Aakash Hasija

Popularity 9/10 Helpfulness 1/10 Language java

Source: www.geeksforgeeks.org

Tags: cycle cycl

Link to this answer
Share Copy Link

Contributed on Aug 11 2022

whoibrar

0 Answers Avg Quality 2/10

Detect cycle in an undirected graph python

Comment

# Python Program to detect cycle in an undirected graph
from collections import defaultdict
 
# This class represents a undirected
# graph using adjacency list representation
 
 
class Graph:
 
    def __init__(self, vertices):
 
        # No. of vertices
        self.V = vertices  # No. of vertices
 
        # Default dictionary to store graph
        self.graph = defaultdict(list)
 
    # Function to add an edge to graph
    def addEdge(self, v, w):
 
        # Add w to v_s list
        self.graph[v].append(w)
 
        # Add v to w_s list
        self.graph[w].append(v)
 
    # A recursive function that uses
    # visited[] and parent to detect
    # cycle in subgraph reachable from vertex v.
    def isCyclicUtil(self, v, visited, parent):
 
        # Mark the current node as visited
        visited[v] = True
 
        # Recur for all the vertices
        # adjacent to this vertex
        for i in self.graph[v]:
 
            # If the node is not
            # visited then recurse on it
            if visited[i] == False:
                if(self.isCyclicUtil(i, visited, v)):
                    return True
            # If an adjacent vertex is
            # visited and not parent
            # of current vertex,
            # then there is a cycle
            elif parent != i:
                return True
 
        return False
 
    # Returns true if the graph
    # contains a cycle, else false.
 
    def isCyclic(self):
 
        # Mark all the vertices
        # as not visited
        visited = [False]*(self.V)
 
        # Call the recursive helper
        # function to detect cycle in different
        # DFS trees
        for i in range(self.V):
 
            # Don't recur for u if it
            # is already visited
            if visited[i] == False:
                if(self.isCyclicUtil
                   (i, visited, -1)) == True:
                    return True
 
        return False
 
 
# Create a graph given in the above diagram
g = Graph(5)
g.addEdge(1, 0)
g.addEdge(1, 2)
g.addEdge(2, 0)
g.addEdge(0, 3)
g.addEdge(3, 4)
 
if g.isCyclic():
    print("Graph contains cycle")
else:
    print("Graph does not contain cycle ")
g1 = Graph(3)
g1.addEdge(0, 1)
g1.addEdge(1, 2)
 
 
if g1.isCyclic():
    print("Graph contains cycle")
else:
    print("Graph does not contain cycle ")
 
# This code is contributed by Neelam Yadav

Popularity 9/10 Helpfulness 1/10 Language python

Source: www.geeksforgeeks.org

Tags: cycle detect d

Link to this answer
Share Copy Link

Contributed on Aug 11 2022

whoibrar

0 Answers Avg Quality 2/10

Detect cycle in an undirected graph

Contents

More Related Answers

Detect cycle in an undirected graph

Closely Related Answers

Detect cycle in an undirected graph

Detect cycle in an undirected graph python

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.