Given a directed graph G **N** nodes and **E** Edges consisting of nodes valued** [0, N – 1] **and a 2D array **Edges[][2] **of type {**u**, **v**} that denotes a directed edge between vertices **u **and **v**. The task is to find the nodes that are not part of any cycle in the given graph **G**.

**Examples:**

Input:N = 4, E = 4, Edges[][2] = { {0, 2}, {0, 1}, {2, 3}, {3, 0} }Output:1Explanation:

From the given graph above there exists a cycle between the nodes 0 -> 2 -> 3 -> 0.

Node which doesn’t occurs in any cycle is 1.

Hence, print 1.

Input:N = 6, E = 7, Edges[][2] = { {0, 1}, {0, 2}, {1, 3}, {2, 1}, {2, 5}, {3, 0}, {4, 5}}Output:4 5Explanation:

From the given graph above there exists a cycle between the nodes:

1) 0 -> 1 -> 3 -> 0.

2) 0 -> 2 -> 1 -> 3 -> 0.

Nodes which doesn’t occurs in any cycle are 4 and 5.

Hence, print 4 and 5.

**Naive Approach:** The simplest approach is to detect a cycle in a directed graph for each node in the given graph and print only those nodes that are not a part of any cycle in the given graph.

**Time Complexity:** O(V * (V + E)), where V is the number of vertices and E is the number of edges.**Auxiliary Space:** O(V)

**Efficient Approach:** To optimize the above approach, the idea is to store the intermediate node as a **visited cycle node** whenever any cycle in the given graph. To implement this part use an auxiliary array **cyclePart[]** that will store the intermediate cycle node while performing the DFS Traversal. Below are the steps:

- Initialize an auxiliary array
**cyclePart[]**of size**N**, such that if**cyclePart[i] = 0**, then**i**node doesn’t exist in any cycle.^{th} - Initialize an auxiliary array
**recStack[]**of size**N**, such that it will store the visited node in the recursion stack by marking that node as**true**. - Perform the DFS Traversal on the given graph for each unvisited node and do the following:
- Now find a cycle in the given graph, whenever a cycle is found, mark the node in
**cyclePart[]**as**true**as this node is a part of the cycle. - If any
**node**is visited in the recursive call and is**recStack[node]**is also true then that node is a part of the cycle then mark that node as**true**.

- Now find a cycle in the given graph, whenever a cycle is found, mark the node in
- After performing the
**DFS Traversal**, traverse the array**cyclePart[]**and print all those nodes that are marked as**false**as these nodes are not the part of any cycle.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `class` `Graph { ` ` ` ` ` `// No. of vertices ` ` ` `int` `V; ` ` ` ` ` `// Stores the Adjacency List ` ` ` `list<` `int` `>* adj; ` ` ` `bool` `printNodesNotInCycleUtil( ` ` ` `int` `v, ` `bool` `visited[], ` `bool` `* rs, ` ` ` `bool` `* cyclePart); ` ` ` `public` `: ` ` ` `// Constructor ` ` ` `Graph(` `int` `V); ` ` ` ` ` `// Member Functions ` ` ` `void` `addEdge(` `int` `v, ` `int` `w); ` ` ` `void` `printNodesNotInCycle(); ` `}; ` ` ` `// Function to initialize the graph ` `Graph::Graph(` `int` `V) ` `{ ` ` ` `this` `->V = V; ` ` ` `adj = ` `new` `list<` `int` `>[V]; ` `} ` ` ` `// Function that adds directed edges ` `// between node v with node w ` `void` `Graph::addEdge(` `int` `v, ` `int` `w) ` `{ ` ` ` `adj[v].push_back(w); ` `} ` ` ` `// Function to perform DFS Traversal ` `// and return true if current node v ` `// formes cycle ` `bool` `Graph::printNodesNotInCycleUtil( ` ` ` `int` `v, ` `bool` `visited[], ` ` ` `bool` `* recStack, ` `bool` `* cyclePart) ` `{ ` ` ` ` ` `// If node v is unvisited ` ` ` `if` `(visited[v] == ` `false` `) { ` ` ` ` ` `// Mark the current node as ` ` ` `// visited and part of ` ` ` `// recursion stack ` ` ` `visited[v] = ` `true` `; ` ` ` `recStack[v] = ` `true` `; ` ` ` ` ` `// Traverse the Adjacency ` ` ` `// List of current node v ` ` ` `for` `(` `auto` `& child : adj[v]) { ` ` ` ` ` `// If child node is unvisited ` ` ` `if` `(!visited[child] ` ` ` `&& printNodesNotInCycleUtil( ` ` ` `child, visited, ` ` ` `recStack, cyclePart)) { ` ` ` ` ` `// If child node is a part ` ` ` `// of cycle node ` ` ` `cyclePart[child] = 1; ` ` ` `return` `true` `; ` ` ` `} ` ` ` ` ` `// If child node is visited ` ` ` `else` `if` `(recStack[child]) { ` ` ` `cyclePart[child] = 1; ` ` ` `return` `true` `; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// Remove vertex from recursion stack ` ` ` `recStack[v] = ` `false` `; ` ` ` `return` `false` `; ` `} ` ` ` `// Function that print the nodes for ` `// the given directed graph that are ` `// not present in any cycle ` `void` `Graph::printNodesNotInCycle() ` `{ ` ` ` ` ` `// Stores the visited node ` ` ` `bool` `* visited = ` `new` `bool` `[V]; ` ` ` ` ` `// Stores nodes in recursion stack ` ` ` `bool` `* recStack = ` `new` `bool` `[V]; ` ` ` ` ` `// Stores the nodes that are ` ` ` `// part of any cycle ` ` ` `bool` `* cyclePart = ` `new` `bool` `[V]; ` ` ` ` ` `for` `(` `int` `i = 0; i < V; i++) { ` ` ` `visited[i] = ` `false` `; ` ` ` `recStack[i] = ` `false` `; ` ` ` `cyclePart[i] = ` `false` `; ` ` ` `} ` ` ` ` ` `// Traverse each node ` ` ` `for` `(` `int` `i = 0; i < V; i++) { ` ` ` ` ` `// If current node is unvisited ` ` ` `if` `(!visited[i]) { ` ` ` ` ` `// Perform DFS Traversal ` ` ` `if` `(printNodesNotInCycleUtil( ` ` ` `i, visited, recStack, ` ` ` `cyclePart)) { ` ` ` ` ` `// Mark as cycle node ` ` ` `// if it return true ` ` ` `cyclePart[i] = 1; ` ` ` `} ` ` ` `} ` ` ` `} ` ` ` ` ` `// Traverse the cyclePart[] ` ` ` `for` `(` `int` `i = 0; i < V; i++) { ` ` ` ` ` `// If node i is not a part ` ` ` `// of any cycle ` ` ` `if` `(cyclePart[i] == 0) { ` ` ` `cout << i << ` `" "` `; ` ` ` `} ` ` ` `} ` `} ` ` ` `// Function that print the nodes for ` `// the given directed graph that are ` `// not present in any cycle ` `void` `solve(` `int` `N, ` `int` `E, ` ` ` `int` `Edges[][2]) ` `{ ` ` ` ` ` `// Initialize the graph g ` ` ` `Graph g(N); ` ` ` ` ` `// Create a directed Graph ` ` ` `for` `(` `int` `i = 0; i < E; i++) { ` ` ` `g.addEdge(Edges[i][0], ` ` ` `Edges[i][1]); ` ` ` `} ` ` ` ` ` `// Function Call ` ` ` `g.printNodesNotInCycle(); ` `} ` ` ` `// Driver Code ` `int` `main() ` `{ ` ` ` `// Given Number of nodes ` ` ` `int` `N = 6; ` ` ` ` ` `// Given Edges ` ` ` `int` `E = 7; ` ` ` ` ` `int` `Edges[][2] = { { 0, 1 }, { 0, 2 }, ` ` ` `{ 1, 3 }, { 2, 1 }, ` ` ` `{ 2, 5 }, { 3, 0 }, ` ` ` `{ 4, 5 } }; ` ` ` ` ` `// Function Call ` ` ` `solve(N, E, Edges); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

4 5

**Time Complexity:** O(V + E)**Space Complexity:** O(V)

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.

## Recommended Posts:

- Maximize number of nodes which are not part of any edge in a Graph
- Print negative weight cycle in a Directed Graph
- Detect Cycle in a Directed Graph
- Detect Cycle in a directed graph using colors
- Detect Cycle in a Directed Graph using BFS
- Detect cycle in Directed Graph using Topological Sort
- Detect cycle in the graph using degrees of nodes of graph
- Construct a graph which does not contain any pair of adjacent nodes with same value
- Minimum edges to be added in a directed graph so that any node can be reachable from a given node
- Convert the undirected graph into directed graph such that there is no path of length greater than 1
- Convert undirected connected graph to strongly connected directed graph
- Minimum Cost Path in a directed graph via given set of intermediate nodes
- Minimum Cost of Simple Path between two nodes in a Directed and Weighted Graph
- Check if a directed graph is connected or not
- Check if incoming edges in a vertex of directed graph is equal to vertex itself or not
- Count of all cycles without any inner cycle in a given Graph
- Find any simple cycle in an undirected unweighted Graph
- Check if a cycle of length 3 exists or not in a graph that satisfy a given condition
- Maximize sum of all elements which are not a part of the Longest Increasing Subsequence
- Find if there is a path between two vertices in a directed graph

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.