Skip to content
Related Articles

Related Articles

Improve Article

Conversion of an Undirected Graph to a Directed Euler Circuit

  • Last Updated : 31 Mar, 2021

Given an undirected graph with V nodes (say numbered from 1 to V) and E edges, the task is to check whether the graph is an Euler Graph or not and if so then convert it into a Directed Euler Circuit.

A Directed Euler Circuit is a directed graph such that if you start traversing the graph from any node and travel through each edge exactly once you will end up on the starting node. 
 

Note: While traversing a Euler circuit every edge is traversed exactly once. A node can be traversed more than once if needed but an edge cannot be traversed more than once.

Example: 

Input: 
 



Output: 
1 2 
2 5 
5 1 
2 4 
4 3 
3 2 
Explanation: 
The Directed Euler Circuit for the given undirected graph will be: 
 

 

Approach: 
 

  1. First, we need to make sure the given Undirected Graph is Eulerian or not. If the undirected graph is not Eulerian we cannot convert it to a Directed Eulerian Graph. 
    • To check it we just need to calculate the degree of every node. If the degree of all nodes is even and not equal to 0 then the graph is Eulerian. 
  2. We will be using Depth First Search Traversal to assign the directions. 
    • While traversing we will set the direction of an edge from parent to child. We will maintain a map to make sure an edge is traversed only once. 

Below is the implementation of the above algorithm:

C++




// C++ program to Convert an
// Undirected Graph to a
// Directed Euler Circuit
 
#include <bits/stdc++.h>
using namespace std;
 
vector<int> g[100];
 
// Array to store degree
// of nodes.
int deg[100] = { 0 };
 
// Map to keep a track of
// visited edges
map<pair<int, int>, int> m1;
 
// Vector to store the edge
// pairs
vector<pair<int, int> > v;
 
// Function to add Edge
void addEdge(int u, int v)
{
    deg[u]++;
    deg[v]++;
    g[u].push_back(v);
    g[v].push_back(u);
}
 
// Function to check if graph
// is Eulerian or not
bool CheckEulerian(int n)
{
    int check = 0;
    for (int i = 1; i <= n; i++) {
        // Checking if odd degree
        // or zero degree nodes
        // are present
        if (deg[i] % 2 || deg[i] == 0) {
            check = 1;
            break;
        }
    }
 
    // If any degree is odd or
    // any vertex has degree 0
    if (check) {
        return false;
    }
    return true;
}
// DFS Function to assign the direction
void DirectedEuler(int node,
                   vector<int> g[])
{
    for (auto i = g[node].begin();
         i != g[node].end(); i++) {
        // Checking if edge is already
        // visited
        if (m1[make_pair(node, *i)]
            || m1[make_pair(*i, node)])
            continue;
 
        m1[make_pair(node, *i)]++;
 
        // Storing the edge
        v.push_back(make_pair(node, *i));
        DirectedEuler(*i, g);
    }
}
 
// Function prints the convert
// Directed graph
void ConvertDirectedEuler(int n,
                          int e)
{
    if (!CheckEulerian(n)) {
        cout << "NOT POSSIBLE"
             << endl;
        return;
    }
 
    DirectedEuler(1, g);
 
    // Printing directed edges
    for (auto i = v.begin();
         i != v.end(); i++) {
        cout << (*i).first
             << " "
             << (*i).second
             << endl;
    }
}
// Driver code
int main()
{
    int N = 5;
    int E = 6;
    addEdge(1, 2);
    addEdge(1, 5);
    addEdge(5, 2);
    addEdge(2, 4);
    addEdge(2, 3);
    addEdge(4, 3);
 
    ConvertDirectedEuler(N, E);
}

Java




// Java program to Convert an
// Undirected Graph to a
// Directed Euler Circuit
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG{
 
// Pair class to store Key in map
static class Pair
{
    int first;
    int second;
 
    Pair(int first, int second)
    {
        this.first = first;
        this.second = second;
    }
 
    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = 1;
        result = prime * result + first;
        result = prime * result + second;
        return result;
    }
 
    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Pair other = (Pair) obj;
        if (first != other.first)
            return false;
        if (second != other.second)
            return false;
             
        return true;
    }
}
 
// To store graph
static ArrayList<Integer> g[];
 
// Array to store degree of nodes.
static int deg[];
 
// Vector to store the edge pairs
static ArrayList<Pair> v;
 
// Map to keep a track of
// visited edges
static HashMap<Pair, Integer> m1;
 
@SuppressWarnings("unchecked")
static void initialize()
{
    g = new ArrayList[100];
    for(int i = 0; i < 100; i++)
        g[i] = new ArrayList<>();
 
    deg = new int[100];
    v = new ArrayList<>();
    m1 = new HashMap<>();
}
 
// Function to add Edge
static void addEdge(int u, int v)
{
    deg[u]++;
    deg[v]++;
    g[u].add(v);
    g[v].add(u);
}
 
// Function to check if graph
// is Eulerian or not
static boolean CheckEulerian(int n)
{
    int check = 0;
    for(int i = 1; i <= n; i++)
    {
         
        // Checking if odd degree
        // or zero degree nodes
        // are present
        if (deg[i] % 2 == 1 || deg[i] == 0)
        {
            check = 1;
            break;
        }
    }
 
    // If any degree is odd or
    // any vertex has degree 0
    if (check == 1)
    {
        return false;
    }
    return true;
}
 
// DFS Function to assign the direction
static void DirectedEuler(int node,
                          ArrayList<Integer> g[])
{
    for(int i : g[node])
    {
         
        // Checking if edge is already
        // visited
        if (m1.containsKey(new Pair(node, i)) ||
            m1.containsKey(new Pair(i, node)))
            continue;
 
        m1.put(new Pair(node, i), 1);
 
        // Storing the edge
        v.add(new Pair(node, i));
        DirectedEuler(i, g);
    }
}
 
// Function prints the convert
// Directed graph
static void ConvertDirectedEuler(int n, int e)
{
    if (!CheckEulerian(n))
    {
        System.out.println("NOT POSSIBLE");
        return;
    }
 
    DirectedEuler(1, g);
 
    // Printing directed edges
    for(Pair p : v)
    {
        System.out.println(p.first + " " + p.second);
    }
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 5;
    int E = 6;
 
    // To initialize
    initialize();
 
    addEdge(1, 2);
    addEdge(1, 5);
    addEdge(5, 2);
    addEdge(2, 4);
    addEdge(2, 3);
    addEdge(4, 3);
 
    ConvertDirectedEuler(N, E);
}
}
 
// This code is contributed by Kingash

Python3




# Python program to Convert an
# Undirected Graph to a
# Directed Euler Circuit
from typing import List
g = [[] for _ in range(100)]
 
# Array to store degree
# of nodes.
deg = [0 for _ in range(100)]
 
# Map to keep a track of
# visited edges
m1 = dict()
 
# Vector to store the edge
# pairs
v = []
 
# Function to add Edge
def addEdge(u: int, v: int) -> None:
    global deg, g
    deg[u] += 1
    deg[v] += 1
    g[u].append(v)
    g[v].append(u)
 
# Function to check if graph
# is Eulerian or not
def CheckEulerian(n: int) -> bool:
 
    check = 0
    for i in range(1, n + 1):
       
        # Checking if odd degree
        # or zero degree nodes
        # are present
        if (deg[i] % 2 or deg[i] == 0):
            check = 1
            break
 
    # If any degree is odd or
    # any vertex has degree 0
    if (check):
        return False
 
    return True
 
# DFS Function to assign the direction
def DirectedEuler(node: int, g: List[List[int]]) -> None:
 
    for i in g[node]:
       
        # Checking if edge is already
        # visited
        if ((node, i) in m1 or (i, node) in m1):
            continue
 
        if (node, i) not in m1:
            m1[(node, i)] = 0
        m1[(node, i)] += 1
 
        # Storing the edge
        v.append((node, i))
        DirectedEuler(i, g)
 
# Function prints the convert
# Directed graph
def ConvertDirectedEuler(n: int, e: int) -> None:
    if (not CheckEulerian(n)):
        print("NOT POSSIBLE")
        return
    DirectedEuler(1, g)
 
    # Printing directed edges
    for i in v:
        print("{} {}".format(i[0], i[1]))
 
# Driver code
if __name__ == "__main__":
 
    N = 5
    E = 6
    addEdge(1, 2)
    addEdge(1, 5)
    addEdge(5, 2)
    addEdge(2, 4)
    addEdge(2, 3)
    addEdge(4, 3)
 
    ConvertDirectedEuler(N, E)
 
# This code is contributed by sanjeev2552
Output: 
1 2
2 5
5 1
2 4
4 3
3 2

 

Time Complexity: O(( V + E ) * log( E )) 
Space Complexity: O(max( V, E ))
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :