# Eulerian Path in undirected graph

• Difficulty Level : Medium
• Last Updated : 14 Sep, 2022

Given an adjacency matrix representation of an undirected graph. Find if there is any Eulerian Path in the graph. If there is no path print “No Solution”. If there is any path print the path.

Examples:

```Input : [[0, 1, 0, 0, 1],
[1, 0, 1, 1, 0],
[0, 1, 0, 1, 0],
[0, 1, 1, 0, 0],
[1, 0, 0, 0, 0]]

Output : 5 -> 1 -> 2 -> 4 -> 3 -> 2

Input : [[0, 1, 0, 1, 1],
[1, 0, 1, 0, 1],
[0, 1, 0, 1, 1],
[1, 1, 1, 0, 0],
[1, 0, 1, 0, 0]]
Output : "No Solution"```

The base case of this problem is if the number of vertices with an odd number of edges(i.e. odd degree) is greater than 2 then there is no Eulerian path.
If it has the solution and all the nodes have an even number of edges then we can start our path from any of the nodes.
If it has the solution and exactly two vertices have an odd number of edges then we have to start our path from one of these two vertices.
There will not be the case where exactly one vertex has an odd number of edges, as there is an even number of edges in total.

The process to Find the Path:

1. First, take an empty stack and an empty path.
2. If all the vertices have an even number of edges then start from any of them. If two of the vertices have an odd number of edges then start from one of them. Set variable current to this starting vertex.
3. If the current vertex has at least one adjacent node then first discover that node and then discover the current node by backtracking. To do so add the current node to stack, remove the edge between the current node and neighbor node, set current to the neighbor node.
4. If the current node has not any neighbor then add it to the path and pop stack set current to popped vertex.
5. Repeat process 3 and 4 until the stack is empty and the current node has not any neighbor. After the process path variable holds the Eulerian path.

Implementation:

## C++

 `// Efficient C++ program to``// find out Eulerian path``#include ``using` `namespace` `std;` `// Function to find out the path``// It takes the adjacency matrix``// representation of the graph as input``void` `findpath(``int` `graph[], ``int` `n)``{``    ``vector<``int``> numofadj;` `    ``// Find out number of edges each vertex has``    ``for` `(``int` `i = 0; i < n; i++)``        ``numofadj.push_back(accumulate(graph[i],``                                      ``graph[i] + 5, 0));` `    ``// Find out how many vertex has odd number edges``    ``int` `startpoint = 0, numofodd = 0;``    ``for` `(``int` `i = n - 1; i >= 0; i--)``    ``{``        ``if` `(numofadj[i] % 2 == 1)``        ``{``            ``numofodd++;``            ``startpoint = i;``        ``}``    ``}` `    ``// If number of vertex with odd number of edges``    ``// is greater than two return "No Solution".``    ``if` `(numofodd > 2)``    ``{``        ``cout << ``"No Solution"` `<< endl;``        ``return``;``    ``}` `    ``// If there is a path find the path``    ``// Initialize empty stack and path``    ``// take the starting current as discussed``    ``stack<``int``> stack;``    ``vector<``int``> path;``    ``int` `cur = startpoint;` `    ``// Loop will run until there is element in the stack``    ``// or current edge has some neighbour.``    ``while` `(!stack.empty() or``            ``accumulate(graph[cur],``                       ``graph[cur] + 5, 0) != 0)``    ``{``        ``// If current node has not any neighbour``        ``// add it to path and pop stack``        ``// set new current to the popped element``        ``if` `(accumulate(graph[cur],``                       ``graph[cur] + 5, 0) == 0)``        ``{``            ``path.push_back(cur);``            ``cur = stack.top();``            ``stack.pop();``        ``}` `        ``// If the current vertex has at least one``        ``// neighbour add the current vertex to stack,``        ``// remove the edge between them and set the``        ``// current to its neighbour.``        ``else``        ``{``            ``for` `(``int` `i = 0; i < n; i++)``            ``{``                ``if` `(graph[cur][i] == 1)``                ``{``                    ``stack.push(cur);``                    ``graph[cur][i] = 0;``                    ``graph[i][cur] = 0;``                    ``cur = i;``                    ``break``;``                ``}``            ``}``        ``}``    ``}` `    ``// print the path``    ``for` `(``auto` `ele : path) cout << ele << ``" -> "``;``    ``cout << cur << endl;``}` `// Driver Code``int` `main()``{``    ``// Test case 1``    ``int` `graph1[] = {{0, 1, 0, 0, 1},``                       ``{1, 0, 1, 1, 0},``                       ``{0, 1, 0, 1, 0},``                       ``{0, 1, 1, 0, 0},``                       ``{1, 0, 0, 0, 0}};``    ``int` `n = ``sizeof``(graph1) / ``sizeof``(graph1);``    ``findpath(graph1, n);` `    ``// Test case 2``    ``int` `graph2[] = {{0, 1, 0, 1, 1},``                       ``{1, 0, 1, 0, 1},``                       ``{0, 1, 0, 1, 1},``                       ``{1, 1, 1, 0, 0},``                       ``{1, 0, 1, 0, 0}};``    ``n = ``sizeof``(graph1) / ``sizeof``(graph1);``    ``findpath(graph2, n);` `    ``// Test case 3``    ``int` `graph3[] = {{0, 1, 0, 0, 1},``                       ``{1, 0, 1, 1, 1},``                       ``{0, 1, 0, 1, 0},``                       ``{0, 1, 1, 0, 1},``                       ``{1, 1, 0, 1, 0}};``    ``n = ``sizeof``(graph1) / ``sizeof``(graph1);``    ``findpath(graph3, n);``}` `// This code is contributed by``// sanjeev2552`

## Java

 `// Efficient Java program to``// find out Eulerian path``import` `java.util.*;` `class` `GFG``{` `    ``// Function to find out the path``    ``// It takes the adjacency matrix``    ``// representation of the graph as input``    ``static` `void` `findpath(``int``[][] graph, ``int` `n)``    ``{``        ``Vector numofadj = ``new` `Vector<>();` `        ``// Find out number of edges each vertex has``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``numofadj.add(accumulate(graph[i], ``0``));` `        ``// Find out how many vertex has odd number edges``        ``int` `startPoint = ``0``, numofodd = ``0``;``        ``for` `(``int` `i = n - ``1``; i >= ``0``; i--)``        ``{``            ``if` `(numofadj.elementAt(i) % ``2` `== ``1``)``            ``{``                ``numofodd++;``                ``startPoint = i;``            ``}``        ``}` `        ``// If number of vertex with odd number of edges``        ``// is greater than two return "No Solution".``        ``if` `(numofodd > ``2``)``        ``{``            ``System.out.println(``"No Solution"``);``            ``return``;``        ``}` `        ``// If there is a path find the path``        ``// Initialize empty stack and path``        ``// take the starting current as discussed``        ``Stack stack = ``new` `Stack<>();``        ``Vector path = ``new` `Vector<>();``        ``int` `cur = startPoint;` `        ``// Loop will run until there is element in the stack``        ``// or current edge has some neighbour.``        ``while` `(!stack.isEmpty() || accumulate(graph[cur], ``0``) != ``0``)``        ``{` `            ``// If current node has not any neighbour``            ``// add it to path and pop stack``            ``// set new current to the popped element``            ``if` `(accumulate(graph[cur], ``0``) == ``0``)``            ``{``                ``path.add(cur);``                ``cur = stack.pop();` `                ``// If the current vertex has at least one``                ``// neighbour add the current vertex to stack,``                ``// remove the edge between them and set the``                ``// current to its neighbour.``            ``}``            ``else``            ``{``                ``for` `(``int` `i = ``0``; i < n; i++)``                ``{``                    ``if` `(graph[cur][i] == ``1``)``                    ``{``                        ``stack.add(cur);``                        ``graph[cur][i] = ``0``;``                        ``graph[i][cur] = ``0``;``                        ``cur = i;``                        ``break``;``                    ``}``                ``}``            ``}``        ``}` `        ``// print the path``        ``for` `(``int` `ele : path)``            ``System.out.print(ele + ``" -> "``);``        ``System.out.println(cur);``    ``}` `    ``static` `int` `accumulate(``int``[] arr, ``int` `sum)``    ``{``        ``for` `(``int` `i : arr)``            ``sum += i;``        ``return` `sum;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``// Test case 1``        ``int``[][] graph1 = { { ``0``, ``1``, ``0``, ``0``, ``1` `},``                        ``{ ``1``, ``0``, ``1``, ``1``, ``0` `},``                        ``{ ``0``, ``1``, ``0``, ``1``, ``0` `},``                        ``{ ``0``, ``1``, ``1``, ``0``, ``0` `},``                        ``{ ``1``, ``0``, ``0``, ``0``, ``0` `} };``        ``int` `n = graph1.length;``        ``findpath(graph1, n);` `        ``// Test case 2``        ``int``[][] graph2 = { { ``0``, ``1``, ``0``, ``1``, ``1` `},``                        ``{ ``1``, ``0``, ``1``, ``0``, ``1` `},``                        ``{ ``0``, ``1``, ``0``, ``1``, ``1` `},``                        ``{ ``1``, ``1``, ``1``, ``0``, ``0` `},``                        ``{ ``1``, ``0``, ``1``, ``0``, ``0` `} };``        ``n = graph2.length;``        ``findpath(graph2, n);` `        ``// Test case 3``        ``int``[][] graph3 = { { ``0``, ``1``, ``0``, ``0``, ``1` `},``                        ``{ ``1``, ``0``, ``1``, ``1``, ``1` `},``                        ``{ ``0``, ``1``, ``0``, ``1``, ``0` `},``                        ``{ ``0``, ``1``, ``1``, ``0``, ``1` `},``                        ``{ ``1``, ``1``, ``0``, ``1``, ``0` `} };``        ``n = graph3.length;``        ``findpath(graph3, n);``    ``}``}` `// This code is contributed by``// sanjeev2552`

## Python3

 `# Efficient Python3 program to``# find out Eulerian path` `# Function to find out the path``# It takes the adjacency matrix``# representation of the graph as input``def` `findpath(graph, n):``    ` `    ``numofadj ``=` `[]` `    ``# Find out number of edges each``    ``# vertex has``    ``for` `i ``in` `range``(n):``        ``numofadj.append(``sum``(graph[i]))` `    ``# Find out how many vertex has``    ``# odd number edges``    ``startpoint, numofodd ``=` `0``, ``0``    ``for` `i ``in` `range``(n ``-` `1``, ``-``1``, ``-``1``):``        ``if` `(numofadj[i] ``%` `2` `=``=` `1``):``            ``numofodd ``+``=` `1``            ``startpoint ``=` `i` `    ``# If number of vertex with odd number of edges``    ``# is greater than two return "No Solution".``    ``if` `(numofodd > ``2``):``        ``print``(``"No Solution"``)``        ``return` `    ``# If there is a path find the path``    ``# Initialize empty stack and path``    ``# take the starting current as discussed``    ``stack ``=` `[]``    ``path ``=` `[]``    ``cur ``=` `startpoint` `    ``# Loop will run until there is element in the``    ``# stack or current edge has some neighbour.``    ``while` `(``len``(stack) > ``0` `or` `sum``(graph[cur])!``=` `0``):``        ` `        ``# If current node has not any neighbour``        ``# add it to path and pop stack set new``        ``# current to the popped element``        ``if` `(``sum``(graph[cur]) ``=``=` `0``):``            ``path.append(cur)``            ``cur ``=` `stack[``-``1``]``            ``del` `stack[``-``1``]` `        ``# If the current vertex has at least one``        ``# neighbour add the current vertex to stack,``        ``# remove the edge between them and set the``        ``# current to its neighbour.``        ``else``:``            ``for` `i ``in` `range``(n):``                ``if` `(graph[cur][i] ``=``=` `1``):``                    ``stack.append(cur)``                    ``graph[cur][i] ``=` `0``                    ``graph[i][cur] ``=` `0``                    ``cur ``=` `i``                    ``break` `    ``# Print the path``    ``for` `ele ``in` `path:``        ``print``(ele, end ``=` `" -> "``)``        ` `    ``print``(cur)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Test case 1``    ``graph1 ``=` `[ [ ``0``, ``1``, ``0``, ``0``, ``1` `],``               ``[ ``1``, ``0``, ``1``, ``1``, ``0` `],``               ``[ ``0``, ``1``, ``0``, ``1``, ``0` `],``               ``[ ``0``, ``1``, ``1``, ``0``, ``0` `],``               ``[ ``1``, ``0``, ``0``, ``0``, ``0` `] ]``    ``n ``=` `len``(graph1)``    ``findpath(graph1, n)` `    ``# Test case 2``    ``graph2 ``=` `[ [ ``0``, ``1``, ``0``, ``1``, ``1` `],``               ``[ ``1``, ``0``, ``1``, ``0``, ``1` `],``               ``[ ``0``, ``1``, ``0``, ``1``, ``1` `],``               ``[ ``1``, ``1``, ``1``, ``0``, ``0` `],``               ``[ ``1``, ``0``, ``1``, ``0``, ``0` `] ]``    ``n ``=` `len``(graph2)``    ``findpath(graph2, n)` `    ``# Test case 3``    ``graph3 ``=` `[ [ ``0``, ``1``, ``0``, ``0``, ``1` `],``               ``[ ``1``, ``0``, ``1``, ``1``, ``1` `],``               ``[ ``0``, ``1``, ``0``, ``1``, ``0` `],``               ``[ ``0``, ``1``, ``1``, ``0``, ``1` `],``               ``[ ``1``, ``1``, ``0``, ``1``, ``0` `] ]``    ``n ``=` `len``(graph3)``    ``findpath(graph3, n)` `# This code is contributed by mohit kumar 29`

## C#

 `// Efficient C# program to``// find out Eulerian path``using` `System;``using` `System.Collections.Generic;``class` `GFG{` `// Function to find out the path``// It takes the adjacency matrix``// representation of the graph``// as input``static` `void` `findpath(``int``[,] graph,``                     ``int` `n)``{``  ``List<``int``> numofadj =``            ``new` `List<``int``>();` `  ``// Find out number of edges``  ``// each vertex has``  ``for` `(``int` `i = 0; i < n; i++)``    ``numofadj.Add(accumulate(graph,``                            ``i, 0));` `  ``// Find out how many vertex has``  ``// odd number edges``  ``int` `startPoint = 0, numofodd = 0;``  ``for` `(``int` `i = n - 1; i >= 0; i--)``  ``{``    ``if` `(numofadj[i] % 2 == 1)``    ``{``      ``numofodd++;``      ``startPoint = i;``    ``}``  ``}` `  ``// If number of vertex with odd``  ``// number of edges is greater than``  ``// two return "No Solution".``  ``if` `(numofodd > 2)``  ``{``    ``Console.WriteLine(``"No Solution"``);``    ``return``;``  ``}` `  ``// If there is a path find the path``  ``// Initialize empty stack and path``  ``// take the starting current as``  ``// discussed``  ``Stack<``int``> stack = ``new` `Stack<``int``>();``  ``List<``int``> path = ``new` `List<``int``>();``  ``int` `cur = startPoint;` `  ``// Loop will run until there is element``  ``// in the stack or current edge has some``  ``// neighbour.``  ``while` `(stack.Count != 0 ||``         ``accumulate(graph, cur, 0) != 0)``  ``{` `    ``// If current node has not any``    ``// neighbour add it to path and``    ``// pop stack set new current to``    ``// the popped element``    ``if` `(accumulate(graph,cur, 0) == 0)``    ``{``      ``path.Add(cur);``      ``cur = stack.Pop();` `      ``// If the current vertex has at``      ``// least one neighbour add the``      ``// current vertex to stack, remove``      ``// the edge between them and set the``      ``// current to its neighbour.``    ``}``    ``else``    ``{``      ``for` `(``int` `i = 0; i < n; i++)``      ``{``        ``if` `(graph[cur, i] == 1)``        ``{``          ``stack.Push(cur);``          ``graph[cur, i] = 0;``          ``graph[i, cur] = 0;``          ``cur = i;``          ``break``;``        ``}``      ``}``    ``}``  ``}` `  ``// print the path``  ``foreach` `(``int` `ele ``in` `path)``    ``Console.Write(ele + ``" -> "``);``  ``Console.WriteLine(cur);``}` `static` `int` `accumulate(``int``[,] matrix,``                      ``int` `row, ``int` `sum)``{   ``  ``int` `[]arr = GetRow(matrix,``                     ``row);``  ` ` ``foreach` `(``int` `i ``in` `arr)``   ``sum += i;`` ``return` `sum;``}``  ` `public` `static` `int``[] GetRow(``int``[,] matrix,``                           ``int` `row)``{``  ``var` `rowLength = matrix.GetLength(1);``  ``var` `rowVector = ``new` `int``[rowLength];` `  ``for` `(``var` `i = 0; i < rowLength; i++)``    ``rowVector[i] = matrix[row, i];` `  ``return` `rowVector;``}``  ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``// Test case 1``  ``int``[,] graph1 = {{0, 1, 0, 0, 1},``                   ``{1, 0, 1, 1, 0},``                   ``{0, 1, 0, 1, 0},``                   ``{0, 1, 1, 0, 0},``                   ``{1, 0, 0, 0, 0}};``  ``int` `n = graph1.GetLength(0);``  ``findpath(graph1, n);` `  ``// Test case 2``  ``int``[,] graph2 = {{0, 1, 0, 1, 1},``                   ``{1, 0, 1, 0, 1},``                   ``{0, 1, 0, 1, 1},``                   ``{1, 1, 1, 0, 0},``                   ``{1, 0, 1, 0, 0}};``  ``n = graph2.GetLength(0);``  ``findpath(graph2, n);` `  ``// Test case 3``  ``int``[,] graph3 = {{0, 1, 0, 0, 1},``                   ``{1, 0, 1, 1, 1},``                   ``{0, 1, 0, 1, 0},``                   ``{0, 1, 1, 0, 1},``                   ``{1, 1, 0, 1, 0}};``  ``n = graph3.GetLength(0);``  ``findpath(graph3, n);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output

```4 -> 0 -> 1 -> 3 -> 2 -> 1
No Solution
4 -> 3 -> 2 -> 1 -> 4 -> 0 -> 1 -> 3```

Time Complexity:
The runtime complexity of this algorithm is O(E). This algorithm can also be used to find the Eulerian circuit. If the first and last vertex of the path is the same then it will be an Eulerian circuit.

My Personal Notes arrow_drop_up