# Check whether a directed graph is Eulerian import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Record;

// A category to retailer a graph edge

class Edge

int supply, dest;

public Edge(int supply, int dest)

this.supply = supply;

this.dest = dest;

// A category to signify a graph object

class Graph

// A listing of lists to signify an adjacency record

// shops indegree of a vertex

Record<Integer> in;

// Constructor

Graph(int n)

for (int i = 0; i < n; i++)

// initialize indegree of every vertex by 0

in = new ArrayList<>(Collections.nCopies(n, 0));

// Utility perform so as to add an edge (u, v) to the graph

// add an edge from supply to vacation spot

// increment in-degree of vacation spot vertex by 1

in.set(v, in.get(v) + 1);

class Predominant

{

// Operate to carry out DFS traversal on the graph

public static void DFS(Graph graph, int v, boolean[] found)

// mark the present node as found

found[v] = true;

// do for each edge (v, u)

// `u` isn’t found

if (!found[u])

DFS(graph, u, found);

// Operate to exchange all of the directed edges of the graph with undirected edges

// and produce an undirected graph

public static Graph getUndirectedGraph(Graph graph, int n)

Graph g = new Graph(n);

for (int u = 0; u < n; u++)

for (int v: graph.adjList.get(u))         // for each edge (u, v)

return g;

// Operate to examine if all vertices with a non-zero diploma in a graph

// belong to a single linked part

public static boolean isConnected(Graph graph, int n)

// preserve observe of all beforehand visited vertices in DFS

boolean[] visited = new boolean[n];

// begin DFS from the primary vertex with a non-zero diploma

for (int i = 0; i < n; i++)

DFS(graph, i, visited);

break;

// if a single DFS name could not go to all vertices with a non-zero diploma,

// the graph accommodates multiple linked part

for (int i = 0; i < n; i++)

if (!visited[i] && graph.adjList.get(i).measurement() > 0)

return false;

return true;

// Operate to examine if a directed graph has an Eulerian path

public static boolean hasEulerPath(Graph graph, int n)

/*

The next loop checks the next situations to find out if an

Eulerian path can exist or not:

a. At most one vertex within the graph has `out-degree = 1 + in-degree`.

b. At most one vertex within the graph has `in-degree = 1 + out-degree`.

c. Relaxation all vertices have `in-degree == out-degree`.

If both of the above situation fails, the Euler path cannot exist.

*/

boolean x = false, y = false;

for (int i = 0; i < n; i++)

int in_degree = graph.in.get(i);

if (out_degree != in_degree)

if (!x && out_degree in_degree == 1)

x = true;

else if (!y && in_degree out_degree == 1)

y = true;

else

return false;

// contemplate given edges as undirected and examine if all non-isolated vertices

// belong to a single linked part

return isConnected(getUndirectedGraph(graph, n), n);

public static void principal(String[] args)

// Record of graph edges as per the above diagram

Record<Edge> edges = Arrays.asList(new Edge(0, 1), new Edge(1, 2),

new Edge(2, 3), new Edge(3, 1), new Edge(1, 4), new Edge(4, 3),

new Edge(3, 0), new Edge(0, 5), new Edge(5, 4)

);

// whole variety of nodes within the graph (labelled from 0 to five)

int n = 6;

// construct a directed graph from the above edges

Graph graph = new Graph(n);

// add edges to the directed graph

for (Edge edge: edges)

if (hasEulerPath(graph, n))

System.out.println(“The graph has an Eulerian path”);

else

System.out.println(“The Graph does not have an Eulerian path”);

}