Related Articles
Find dependencies of each Vertex in a Directed Graph
• Difficulty Level : Hard
• Last Updated : 01 Jun, 2020

Given a directed graph containing N vertices and M edges, the task is to find all the dependencies of each vertex in the graph and the vertex with the minimum dependency.

A directed graph (or digraph) is a set of nodes connected by edges, where the edges have a direction associated with them.

For example, an arc (x, y) is considered to be directed from x to y, and the arc (y, x) is the inverted link. Y is a direct successor of x, and x is a direct predecessor of y.

The dependency is the number of connections to different vertices which are dependent on the current vertex.

Examples:

Output:
Vertex 1 dependencies -> 2-> 3
Vertex 2 dependencies -> 3-> 1
Vertex 3 dependencies -> 1-> 2
Node 1 has the minimum number of dependency of 2.
Explanation:
Vertex 1 is dependent on 2 and 3.
Similarly, vertex 2 and 3 on (3, 1) and (1, 2) respectively.
Therefore, the minimum number of dependency among all vertices is 2.

Output:
Vertex 1 dependency -> 2-> 3-> 4-> 5-> 6
Vertex 2 dependency -> 6
Vertex 3 dependency -> 4-> 5-> 6
Vertex 4 dependency -> 5-> 6
Vertex 5 dependency -> 6
Vertex 6 is not dependent on any vertex.
Node 6 has the minimum dependency of 0
Explanation:
Vertex 1 is dependent on (3, 4, 5, 6, 7). Similarly, vertex 2 on (6), vertex 3 on (4, 5, 6), vertex 4 on (5, 6), vertex 5 on (6) and vertex 6 is not dependent on any.
Therefore, the minimum number of dependency among all vertices is 0.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: The idea is to use depth-first search(DFS) to solve this problem.

• Get the directed graph as the input.
• Perform the DFS on the graph and explore all the nodes of the graph.
• While exploring the neighbours of the node, add 1 to count and finally return the count which signifies the number of dependencies.
• Finally, find the node with the minimum number of dependencies.

Below is the implementation of the above approach:

 `// C++ program to find the ` `// dependency of each node ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Defining the graph ` `class` `Graph { ` ` `  `    ``// Variable to store the ` `    ``// number of vertices ` `    ``int` `V; ` ` `  `    ``// Adjacency list ` `    ``list<``int``>* adjList; ` ` `  `    ``// Initializing the graph ` `public``: ` `    ``Graph(``int` `v) ` `    ``{ ` `        ``V = v; ` `        ``adjList = ``new` `list<``int``>[V]; ` `    ``} ` ` `  `    ``// Adding edges ` `    ``void` `addEdge(``int` `u, ``int` `v, ` `                 ``bool` `bidir = ``true``) ` `    ``{ ` `        ``adjList[u].push_back(v); ` `        ``if` `(bidir) { ` `            ``adjList[u].push_back(v); ` `        ``} ` `    ``} ` ` `  `    ``// Performing DFS on each node ` `    ``int` `dfs(``int` `src) ` `    ``{ ` `        ``// Map is used to mark ` `        ``// the current node as visited ` `        ``map<``int``, ``bool``> visited; ` `        ``vector<``int``> dependent; ` `        ``int` `count = 0; ` ` `  `        ``stack<``int``> s; ` ` `  `        ``// Push the current vertex ` `        ``// to the stack which ` `        ``// stores the result ` `        ``s.push(src); ` ` `  `        ``visited[src] = ``true``; ` ` `  `        ``// Traverse through the vertices ` `        ``// until the stack is empty ` `        ``while` `(!s.empty()) { ` `            ``int` `n = s.top(); ` `            ``s.pop(); ` ` `  `            ``// Recur for all the vertices ` `            ``// adjacent to this vertex ` `            ``for` `(``auto` `i : adjList[n]) { ` ` `  `                ``// If the vertices are ` `                ``// not visited ` `                ``if` `(!visited[i]) { ` `                    ``dependent.push_back(i + 1); ` `                    ``count++; ` ` `  `                    ``// Mark the vertex as ` `                    ``// visited ` `                    ``visited[i] = ``true``; ` ` `  `                    ``// Push the current vertex to ` `                    ``// the stack which stores ` `                    ``// the result ` `                    ``s.push(i); ` `                ``} ` `            ``} ` `        ``} ` ` `  `        ``// If the vertex has 0 dependency ` `        ``if` `(!count) { ` `            ``cout << ``"Vertex "` `<< src + 1 ` `                 ``<< ``" is not dependent on any vertex.\n"``; ` `            ``return` `count; ` `        ``} ` ` `  `        ``cout << ``"Vertex "` `<< src + 1 << ``" dependency "``; ` `        ``for` `(``auto` `i : dependent) { ` `            ``cout << ``"-> "` `<< i; ` `        ``} ` `        ``cout << ``"\n"``; ` `        ``return` `count; ` `    ``} ` `}; ` ` `  `// Function to find the ` `// dependency of each node ` `void` `operations(``int` `arr[], ` `                ``int` `n, ``int` `m) ` `{ ` `    ``// Creating a new graph ` `    ``Graph g(n); ` ` `  `    ``for` `(``int` `i = 0; i < m; i++) { ` `        ``g.addEdge(arr[i], ` `                  ``arr[i], ``false``); ` `    ``} ` ` `  `    ``int` `ans = INT_MAX; ` `    ``int` `node = 0; ` ` `  `    ``// Iterating through the graph ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``int` `c = g.dfs(i); ` ` `  `        ``// Finding the node with ` `        ``// minimum number of ` `        ``// dependency ` `        ``if` `(c < ans) { ` `            ``ans = c; ` `            ``node = i + 1; ` `        ``} ` `    ``} ` `    ``cout << ``"Node "` `<< node ` `         ``<< ``"has minimum dependency of "` `         ``<< ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n, m; ` ` `  `    ``n = 6, m = 6; ` ` `  `    ``// Defining the edges of the ` `    ``// graph ` `    ``int` `arr[] = { { 0, 1 }, ` `                     ``{ 0, 2 }, ` `                     ``{ 2, 3 }, ` `                     ``{ 4, 5 }, ` `                     ``{ 3, 4 }, ` `                     ``{ 1, 5 } }; ` ` `  `    ``operations(arr, n, m); ` ` `  `    ``return` `0; ` `} `

Output:

```Vertex 1 dependency -> 2-> 3-> 4-> 5-> 6
Vertex 2 dependency -> 6
Vertex 3 dependency -> 4-> 5-> 6
Vertex 4 dependency -> 5-> 6
Vertex 5 dependency -> 6
Vertex 6 is not dependent on any vertex.
Node 6has minimum dependency of 0
```

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :