Euler Circuit in a Directed Graph
Last Updated : 31 Jan, 2023
Eulerian Path is a path in graph that visits every edge exactly once. Eulerian Circuit is an Eulerian Path which starts and ends on the same vertex.
A graph is said to be eulerian if it has a eulerian cycle. We have discussed eulerian circuit for an undirected graph. In this post, the same is discussed for a directed graph.
For example, the following graph has eulerian cycle as {1, 0, 3, 4, 0, 2, 1}
How to check if a directed graph is eulerian?
A directed graph has an eulerian cycle if following conditions are true
- All vertices with nonzero degree belong to a single strongly connected component.
- In degree is equal to the out degree for every vertex.
We can detect singly connected component using Kosaraju’s DFS based simple algorithm.
To compare in degree and out-degree, we need to store in degree and out-degree of every vertex. Out degree can be obtained by the size of an adjacency list. In degree can be stored by creating an array of size equal to the number of vertices.
Following implementations of above approach.
C++ // A C++ program to check if a given directed graph is Eulerian or not #include<iostream> #include <list> #define CHARS 26 using namespace std; // A class that represents an undirected graph class Graph { int V; // No. of vertices list<int> *adj; // A dynamic array of adjacency lists int *in; public: // Constructor and destructor Graph(int V); ~Graph() { delete [] adj; delete [] in; } // function to add an edge to graph void addEdge(int v, int w) { adj[v].push_back(w); (in[w])++; } // Method to check if this graph is Eulerian or not bool isEulerianCycle(); // Method to check if all non-zero degree vertices are connected bool isSC(); // Function to do DFS starting from v. Used in isConnected(); void DFSUtil(int v, bool visited[]); Graph getTranspose(); }; Graph::Graph(int V) { this->V = V; adj = new list<int>[V]; in = new int[V]; for (int i = 0; i < V; i++) in[i] = 0; } /* This function returns true if the directed graph has a eulerian cycle, otherwise returns false */ bool Graph::isEulerianCycle() { // Check if all non-zero degree vertices are connected if (isSC() == false) return false; // Check if in degree and out degree of every vertex is same for (int i = 0; i < V; i++) if (adj[i].size() != in[i]) return false; return true; } // A recursive function to do DFS starting from v void Graph::DFSUtil(int v, bool visited[]) { // Mark the current node as visited and print it visited[v] = true; // Recur for all the vertices adjacent to this vertex list<int>::iterator i; for (i = adj[v].begin(); i != adj[v].end(); ++i) if (!visited[*i]) DFSUtil(*i, visited); } // Function that returns reverse (or transpose) of this graph // This function is needed in isSC() Graph Graph::getTranspose() { Graph g(V); for (int v = 0; v < V; v++) { // Recur for all the vertices adjacent to this vertex list<int>::iterator i; for(i = adj[v].begin(); i != adj[v].end(); ++i) { g.adj[*i].push_back(v); (g.in[v])++; } } return g; } // This function returns true if all non-zero degree vertices of // graph are strongly connected (Please refer // https://www.geeksforgeeks.org/connectivity-in-a-directed-graph/ ) bool Graph::isSC() { // Mark all the vertices as not visited (For first DFS) bool visited[V]; for (int i = 0; i < V; i++) visited[i] = false; // Find the first vertex with non-zero degree int n; for (n = 0; n < V; n++) if (adj[n].size() > 0) break; // Do DFS traversal starting from first non zero degrees vertex. DFSUtil(n, visited); // If DFS traversal doesn't visit all vertices, then return false. for (int i = 0; i < V; i++) if (adj[i].size() > 0 && visited[i] == false) return false; // Create a reversed graph Graph gr = getTranspose(); // Mark all the vertices as not visited (For second DFS) for (int i = 0; i < V; i++) visited[i] = false; // Do DFS for reversed graph starting from first vertex. // Starting Vertex must be same starting point of first DFS gr.DFSUtil(n, visited); // If all vertices are not visited in second DFS, then // return false for (int i = 0; i < V; i++) if (adj[i].size() > 0 && visited[i] == false) return false; return true; } // Driver program to test above functions int main() { // Create a graph given in the above diagram Graph g(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(0, 3); g.addEdge(3, 4); g.addEdge(4, 0); if (g.isEulerianCycle()) cout << "Given directed graph is eulerian n"; else cout << "Given directed graph is NOT eulerian n"; return 0; } // A Java program to check if a given directed graph is Eulerian or not // A class that represents an undirected graph import java.io.*; import java.util.*; import java.util.LinkedList; // This class represents a directed graph using adjacency list class Graph { private int V; // No. of vertices private LinkedList<Integer> adj[];//Adjacency List private int in[]; //maintaining in degree //Constructor Graph(int v) { V = v; adj = new LinkedList[v]; in = new int[V]; for (int i=0; i<v; ++i) { adj[i] = new LinkedList(); in[i] = 0; } } //Function to add an edge into the graph void addEdge(int v,int w) { adj[v].add(w); in[w]++; } // A recursive function to print DFS starting from v void DFSUtil(int v,Boolean visited[]) { // Mark the current node as visited visited[v] = true; int n; // Recur for all the vertices adjacent to this vertex Iterator<Integer> i =adj[v].iterator(); while (i.hasNext()) { n = i.next(); if (!visited[n]) DFSUtil(n,visited); } } // Function that returns reverse (or transpose) of this graph Graph getTranspose() { Graph g = new Graph(V); for (int v = 0; v < V; v++) { // Recur for all the vertices adjacent to this vertex Iterator<Integer> i = adj[v].listIterator(); while (i.hasNext()) { g.adj[i.next()].add(v); (g.in[v])++; } } return g; } // The main function that returns true if graph is strongly // connected Boolean isSC() { // Step 1: Mark all the vertices as not visited (For // first DFS) Boolean visited[] = new Boolean[V]; for (int i = 0; i < V; i++) visited[i] = false; // Step 2: Do DFS traversal starting from the first vertex. DFSUtil(0, visited); // If DFS traversal doesn't visit all vertices, then return false. for (int i = 0; i < V; i++) if (visited[i] == false) return false; // Step 3: Create a reversed graph Graph gr = getTranspose(); // Step 4: Mark all the vertices as not visited (For second DFS) for (int i = 0; i < V; i++) visited[i] = false; // Step 5: Do DFS for reversed graph starting from first vertex. // Starting Vertex must be same starting point of first DFS gr.DFSUtil(0, visited); // If all vertices are not visited in second DFS, then // return false for (int i = 0; i < V; i++) if (visited[i] == false) return false; return true; } /* This function returns true if the directed graph has a eulerian cycle, otherwise returns false */ Boolean isEulerianCycle() { // Check if all non-zero degree vertices are connected if (isSC() == false) return false; // Check if in degree and out degree of every vertex is same for (int i = 0; i < V; i++) if (adj[i].size() != in[i]) return false; return true; } public static void main (String[] args) throws java.lang.Exception { Graph g = new Graph(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(0, 3); g.addEdge(3, 4); g.addEdge(4, 0); if (g.isEulerianCycle()) System.out.println("Given directed graph is eulerian "); else System.out.println("Given directed graph is NOT eulerian "); } } //This code is contributed by Aakash Hasija # A Python3 program to check if a given # directed graph is Eulerian or not from collections import defaultdict class Graph(): def __init__(self, vertices): self.V = vertices self.graph = defaultdict(list) self.IN = [0] * vertices def addEdge(self, v, u): self.graph[v].append(u) self.IN[u] += 1 def DFSUtil(self, v, visited): visited[v] = True for node in self.graph[v]: if visited[node] == False: self.DFSUtil(node, visited) def getTranspose(self): gr = Graph(self.V) for node in range(self.V): for child in self.graph[node]: gr.addEdge(child, node) return gr def isSC(self): visited = [False] * self.V v = 0 for v in range(self.V): if len(self.graph[v]) > 0: break self.DFSUtil(v, visited) # If DFS traversal doesn't visit all # vertices, then return false. for i in range(self.V): if visited[i] == False: return False gr = self.getTranspose() visited = [False] * self.V gr.DFSUtil(v, visited) for i in range(self.V): if visited[i] == False: return False return True def isEulerianCycle(self): # Check if all non-zero degree vertices # are connected if self.isSC() == False: return False # Check if in degree and out degree of # every vertex is same for v in range(self.V): if len(self.graph[v]) != self.IN[v]: return False return True g = Graph(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(0, 3); g.addEdge(3, 4); g.addEdge(4, 0); if g.isEulerianCycle(): print( "Given directed graph is eulerian"); else: print( "Given directed graph is NOT eulerian"); # This code is contributed by Divyanshu Mehta
// A C# program to check if a given // directed graph is Eulerian or not // A class that represents an // undirected graph using System; using System.Collections.Generic; // This class represents a directed // graph using adjacency list class Graph{ // No. of vertices public int V; // Adjacency List public List<int> []adj; // Maintaining in degree public int []init; // Constructor Graph(int v) { V = v; adj = new List<int>[v]; init = new int[V]; for(int i = 0; i < v; ++i) { adj[i] = new List<int>(); init[i] = 0; } } // Function to add an edge into the graph void addEdge(int v, int w) { adj[v].Add(w); init[w]++; } // A recursive function to print DFS // starting from v void DFSUtil(int v, Boolean []visited) { // Mark the current node as visited visited[v] = true; // Recur for all the vertices // adjacent to this vertex foreach(int i in adj[v]) { if (!visited[i]) DFSUtil(i, visited); } } // Function that returns reverse // (or transpose) of this graph Graph getTranspose() { Graph g = new Graph(V); for(int v = 0; v < V; v++) { // Recur for all the vertices // adjacent to this vertex foreach(int i in adj[v]) { g.adj[i].Add(v); (g.init[v])++; } } return g; } // The main function that returns // true if graph is strongly connected Boolean isSC() { // Step 1: Mark all the vertices // as not visited (For first DFS) Boolean []visited = new Boolean[V]; for(int i = 0; i < V; i++) visited[i] = false; // Step 2: Do DFS traversal starting // from the first vertex. DFSUtil(0, visited); // If DFS traversal doesn't visit // all vertices, then return false. for(int i = 0; i < V; i++) if (visited[i] == false) return false; // Step 3: Create a reversed graph Graph gr = getTranspose(); // Step 4: Mark all the vertices as // not visited (For second DFS) for(int i = 0; i < V; i++) visited[i] = false; // Step 5: Do DFS for reversed graph // starting from first vertex. // Starting Vertex must be same // starting point of first DFS gr.DFSUtil(0, visited); // If all vertices are not visited // in second DFS, then return false for(int i = 0; i < V; i++) if (visited[i] == false) return false; return true; } // This function returns true if the // directed graph has a eulerian // cycle, otherwise returns false Boolean isEulerianCycle() { // Check if all non-zero degree // vertices are connected if (isSC() == false) return false; // Check if in degree and out // degree of every vertex is same for(int i = 0; i < V; i++) if (adj[i].Count != init[i]) return false; return true; } // Driver code public static void Main(String[] args) { Graph g = new Graph(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(0, 3); g.addEdge(3, 4); g.addEdge(4, 0); if (g.isEulerianCycle()) Console.WriteLine("Given directed " + "graph is eulerian "); else Console.WriteLine("Given directed " + "graph is NOT eulerian "); } } // This code is contributed by Princi Singh <script> // A Javascript program to check if a given directed graph is Eulerian or not // This class represents a directed graph using adjacency // list representation class Graph { // Constructor constructor(v) { this.V = v; this.adj = new Array(v); this.in=new Array(v); for (let i=0; i<v; ++i) { this.adj[i] = []; this.in[i]=0; } } //Function to add an edge into the graph addEdge(v,w) { this.adj[v].push(w); this.in[w]++; } // A recursive function to print DFS starting from v DFSUtil(v,visited) { // Mark the current node as visited visited[v] = true; let n; // Recur for all the vertices adjacent to this vertex for(let i of this.adj[v]) { n = i; if (!visited[n]) this.DFSUtil(n,visited); } } // Function that returns reverse (or transpose) of this graph getTranspose() { let g = new Graph(this.V); for (let v = 0; v < this.V; v++) { // Recur for all the vertices adjacent to this vertex for(let i of this.adj[v]) { g.adj[i].push(v); (g.in[v])++; } } return g; } // The main function that returns true if graph is strongly // connected isSC() { // Step 1: Mark all the vertices as not visited (For // first DFS) let visited = new Array(this.V); for (let i = 0; i < this.V; i++) visited[i] = false; // Step 2: Do DFS traversal starting from the first vertex. this.DFSUtil(0, visited); // If DFS traversal doesn't visit all vertices, then return false. for (let i = 0; i < this.V; i++) if (visited[i] == false) return false; // Step 3: Create a reversed graph let gr = this.getTranspose(); // Step 4: Mark all the vertices as not visited (For second DFS) for (let i = 0; i < this.V; i++) visited[i] = false; // Step 5: Do DFS for reversed graph starting from first vertex. // Starting Vertex must be same starting point of first DFS gr.DFSUtil(0, visited); // If all vertices are not visited in second DFS, then // return false for (let i = 0; i < this.V; i++) if (visited[i] == false) return false; return true; } /* This function returns true if the directed graph has a eulerian cycle, otherwise returns false */ isEulerianCycle() { // Check if all non-zero degree vertices are connected if (this.isSC() == false) return false; // Check if in degree and out degree of every vertex is same for (let i = 0; i < this.V; i++) if (this.adj[i].length != this.in[i]) return false; return true; } } let g = new Graph(5); g.addEdge(1, 0); g.addEdge(0, 2); g.addEdge(2, 1); g.addEdge(0, 3); g.addEdge(3, 4); g.addEdge(4, 0); if (g.isEulerianCycle()) document.write("Given directed graph is eulerian "); else document.write("Given directed graph is NOT eulerian "); // This code is contributed by avanitrachhadiya2155 </script> OutputGiven directed graph is eulerian n
Time complexity of the above implementation is O(V + E) as Kosaraju’s algorithm takes O(V + E) time. After running Kosaraju’s algorithm we traverse all vertices and compare in degree with out degree which takes O(V) time.
Auxiliary Space : O(V), since an extra visited array of size V is required.
See following as an application of this.
Find if the given array of strings can be chained to form a circle.
Similar Reads
Graph Algorithms Graph is a non-linear data structure like tree data structure. The limitation of tree is, it can only represent hierarchical data. For situations where nodes or vertices are randomly connected with each other other, we use Graph. Example situations where we use graph data structure are, a social net
3 min read
Introduction to Graph Data Structure Graph Data Structure is a non-linear data structure consisting of vertices and edges. It is useful in fields such as social network analysis, recommendation systems, and computer networks. In the field of sports data science, graph data structure can be used to analyze and understand the dynamics of
15+ min read
Graph and its representations A Graph is a non-linear data structure consisting of vertices and edges. The vertices are sometimes also referred to as nodes and the edges are lines or arcs that connect any two nodes in the graph. More formally a Graph is composed of a set of vertices( V ) and a set of edges( E ). The graph is den
12 min read
Types of Graphs with Examples A graph is a mathematical structure that represents relationships between objects by connecting a set of points. It is used to establish a pairwise relationship between elements in a given set. graphs are widely used in discrete mathematics, computer science, and network theory to represent relation
9 min read
Basic Properties of a Graph A Graph is a non-linear data structure consisting of nodes and edges. The nodes are sometimes also referred to as vertices and the edges are lines or arcs that connect any two nodes in the graph. The basic properties of a graph include: Vertices (nodes): The points where edges meet in a graph are kn
4 min read
Applications, Advantages and Disadvantages of Graph Graph is a non-linear data structure that contains nodes (vertices) and edges. A graph is a collection of set of vertices and edges (formed by connecting two vertices). A graph is defined as G = {V, E} where V is the set of vertices and E is the set of edges. Graphs can be used to model a wide varie
7 min read
Transpose graph Transpose of a directed graph G is another directed graph on the same set of vertices with all of the edges reversed compared to the orientation of the corresponding edges in G. That is, if G contains an edge (u, v) then the converse/transpose/reverse of G contains an edge (v, u) and vice versa. Giv
9 min read
Difference Between Graph and Tree Graphs and trees are two fundamental data structures used in computer science to represent relationships between objects. While they share some similarities, they also have distinct differences that make them suitable for different applications. Difference Between Graph and Tree What is Graph?A grap
2 min read
BFS and DFS on Graph
Breadth First Search or BFS for a GraphGiven a undirected graph represented by an adjacency list adj, where each adj[i] represents the list of vertices connected to vertex i. Perform a Breadth First Search (BFS) traversal starting from vertex 0, visiting vertices from left to right according to the adjacency list, and return a list conta
15+ min read
Depth First Search or DFS for a GraphIn Depth First Search (or DFS) for a graph, we traverse all adjacent vertices one by one. When we traverse an adjacent vertex, we completely finish the traversal of all vertices reachable through that adjacent vertex. This is similar to a tree, where we first completely traverse the left subtree and
13 min read
Applications, Advantages and Disadvantages of Depth First Search (DFS)Depth First Search is a widely used algorithm for traversing a graph. Here we have discussed some applications, advantages, and disadvantages of the algorithm. Applications of Depth First Search:1. Detecting cycle in a graph: A graph has a cycle if and only if we see a back edge during DFS. So we ca
4 min read
Applications, Advantages and Disadvantages of Breadth First Search (BFS)We have earlier discussed Breadth First Traversal Algorithm for Graphs. Here in this article, we will see the applications, advantages, and disadvantages of the Breadth First Search. Applications of Breadth First Search: 1. Shortest Path and Minimum Spanning Tree for unweighted graph: In an unweight
4 min read
Iterative Depth First Traversal of GraphGiven a directed Graph, the task is to perform Depth First Search of the given graph.Note: Start DFS from node 0, and traverse the nodes in the same order as adjacency list.Note : There can be multiple DFS traversals of a graph according to the order in which we pick adjacent vertices. Here we pick
10 min read
BFS for Disconnected GraphIn the previous post, BFS only with a particular vertex is performed i.e. it is assumed that all vertices are reachable from the starting vertex. But in the case of a disconnected graph or any vertex that is unreachable from all vertex, the previous implementation will not give the desired output, s
14 min read
Transitive Closure of a Graph using DFSGiven a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u, v) in the given graph. Here reachable means that there is a path from vertex u to v. The reach-ability matrix is called transitive closure of a graph. For example, consider below graph: GraphTr
8 min read
Difference between BFS and DFSBreadth-First Search (BFS) and Depth-First Search (DFS) are two fundamental algorithms used for traversing or searching graphs and trees. This article covers the basic difference between Breadth-First Search and Depth-First Search.Difference between BFS and DFSParametersBFSDFSStands forBFS stands fo
2 min read
Cycle in a Graph
Detect Cycle in a Directed GraphGiven the number of vertices V and a list of directed edges, determine whether the graph contains a cycle or not.Examples: Input: V = 4, edges[][] = [[0, 1], [0, 2], [1, 2], [2, 0], [2, 3]]Cycle: 0 → 2 → 0 Output: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 0 Input: V = 4, edges[][] =
15+ min read
Detect cycle in an undirected graphGiven an undirected graph, the task is to check if there is a cycle in the given graph.Examples:Input: V = 4, edges[][]= [[0, 1], [0, 2], [1, 2], [2, 3]]Undirected Graph with 4 vertices and 4 edgesOutput: trueExplanation: The diagram clearly shows a cycle 0 → 2 → 1 → 0Input: V = 4, edges[][] = [[0,
8 min read
Detect Cycle in a directed graph using colorsGiven a directed graph represented by the number of vertices V and a list of directed edges, determine whether the graph contains a cycle.Your task is to implement a function that accepts V (number of vertices) and edges (an array of directed edges where each edge is a pair [u, v]), and returns true
9 min read
Detect a negative cycle in a Graph | (Bellman Ford)Given a directed weighted graph, your task is to find whether the given graph contains any negative cycles that are reachable from the source vertex (e.g., node 0).Note: A negative-weight cycle is a cycle in a graph whose edges sum to a negative value.Example:Input: V = 4, edges[][] = [[0, 3, 6], [1
15+ min read
Cycles of length n in an undirected and connected graphGiven an undirected and connected graph and a number n, count the total number of simple cycles of length n in the graph. A simple cycle of length n is defined as a cycle that contains exactly n vertices and n edges. Note that for an undirected graph, each cycle should only be counted once, regardle
10 min read
Detecting negative cycle using Floyd WarshallWe are given a directed graph. We need compute whether the graph has negative cycle or not. A negative cycle is one in which the overall sum of the cycle comes negative. Negative weights are found in various applications of graphs. For example, instead of paying cost for a path, we may get some adva
12 min read
Clone a Directed Acyclic GraphA directed acyclic graph (DAG) is a graph which doesn't contain a cycle and has directed edges. We are given a DAG, we need to clone it, i.e., create another graph that has copy of its vertices and edges connecting them. Examples: Input : 0 - - - > 1 - - - -> 4 | / \ ^ | / \ | | / \ | | / \ |
12 min read