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:
Input:
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.
Input:
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.
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 <bits/stdc++.h> 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[][2],
int n, int m)
{ // Creating a new graph
Graph g(n);
for ( int i = 0; i < m; i++) {
g.addEdge(arr[i][0],
arr[i][1], 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[][2] = { { 0, 1 },
{ 0, 2 },
{ 2, 3 },
{ 4, 5 },
{ 3, 4 },
{ 1, 5 } };
operations(arr, n, m);
return 0;
} |
// Java program to find the // dependency of each node import java.util.*;
class Graph {
// Variable to store the
// number of vertices
int V;
// Adjacency list
List<Integer>[] adjList;
// Initializing the graph
public Graph( int v)
{
V = v;
adjList = new ArrayList[V];
for ( int i = 0 ; i < V; i++)
adjList[i] = new ArrayList<>();
}
// Adding edges
void addEdge( int u, int v, boolean bidir)
{
adjList[u].add(v);
if (bidir)
adjList[v].add(u);
}
// Performing DFS on each node
int dfs( int src)
{
// Map is used to mark
// the current node as visited
Map<Integer, Boolean> visited = new HashMap<>();
List<Integer> dependent = new ArrayList<>();
int count = 0 ;
Stack<Integer> s = new Stack<Integer>();
// Push the current vertex
// to the stack which
// stores the result
s.push(src);
visited.put(src, true );
// Traverse through the vertices
// until the stack is empty
while (!s.empty()) {
int n = s.peek();
s.pop();
// Recur for all the vertices
// adjacent to this vertex
for ( int i : adjList[n]) {
// If the vertices are
// not visited
if (!visited.containsKey(i)) {
dependent.add(i + 1 );
count++;
// Mark the vertex as
// visited
visited.put(i, true );
// Push the current vertex to
// the stack which stores
// the result
s.push(i);
}
}
}
// If the vertex has 0 dependency
if (count!= 0 ) {
System.out.print(
"Vertex " + (src + 1 )
+ " is not dependent on any vertex.\n" );
return count;
}
System.out.print( "Vertex " + (src + 1 )
+ " dependency " );
for ( int i : dependent) {
System.out.print( "-> " + i);
}
System.out.println();
return count;
}
} class GFG {
// Function to find the
// dependency of each node
static void operations( int arr[][], int n, int m)
{
// Creating a new graph
Graph g = new Graph(n);
for ( int i = 0 ; i < m; i++) {
g.addEdge(arr[i][ 0 ], arr[i][ 1 ], false );
}
int ans = Integer.MAX_VALUE;
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 ;
}
}
System.out.print( "Node " + node
+ "has minimum dependency of "
+ ans);
}
// Driver code
public static void main(String[] args)
{
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);
}
} // This code is contributed by ishankhandelwals. |
# Python3 program to find the # dependency of each node # Adding edges def addEdge(u, v, bidir = True ):
global adjList
adjList[u].append(v)
if (bidir):
adjList[u].append(v)
# Performing DFS on each node def dfs(src):
global adjList, V
# Map is used to mark
# the current node as visited
visited = [ False for i in range (V + 1 )]
dependent = []
count = 0
s = []
# Push the current vertex
# to the stack which
# stores the result
s.append(src)
visited[src] = True
# Traverse through the vertices
# until the stack is empty
while ( len (s) > 0 ):
n = s[ - 1 ]
del s[ - 1 ]
# Recur for all the vertices
# adjacent to this vertex
for i in adjList[n]:
# If the vertices are
# not visited
if ( not visited[i]):
dependent.append(i + 1 )
count + = 1
# Mark the vertex as
# visited
visited[i] = True
# Push the current vertex to
# the stack which stores
# the result
s.append(i)
# If the vertex has 0 dependency
if ( not count):
print ( "Vertex " , src + 1 ,
" is not dependent on any vertex." )
return count
print ( "Vertex " ,src + 1 , " dependency " ,end = "")
for i in dependent:
print ( "-> " , i, end = "")
print ()
return count
# Function to find the # dependency of each node def operations(arr, n, m):
# Creating a new graph
global adjList
for i in range (m):
addEdge(arr[i][ 0 ], arr[i][ 1 ], False )
ans = 10 * * 18
node = 0
# Iterating through the graph
for i in range (n):
c = dfs(i)
# Finding the node with
# minimum number of
# dependency
if (c < ans):
ans = c
node = i + 1
print ( "Node" , node, "has minimum dependency of " , ans)
# Driver code if __name__ = = '__main__' :
V = 6
adjList = [[] for i in range (V + 1 )]
n, m = 6 , 6
# Defining the edges of the
# graph
arr = [ [ 0 , 1 ],
[ 0 , 2 ],
[ 2 , 3 ],
[ 4 , 5 ],
[ 3 , 4 ],
[ 1 , 5 ] ]
operations(arr, n, m)
# This code is contributed by mohit kumar 29.
|
// C# program to find the // dependency of each node using System;
using System.Collections.Generic;
// Defining the graph public 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
public void addEdge( int u, int v, bool bidir = true )
{
adjList[u].Add(v);
if (bidir) {
adjList[u].Add(v);
}
}
// Performing DFS on each node
public int dfs( int src)
{
// Map is used to mark
// the current node as visited
Dictionary< int , bool > visited
= new Dictionary< int , bool >();
List< int > dependent = new List< int >();
int count = 0;
Stack< int > s = new Stack< int >();
// Push the current vertex
// to the stack which
// stores the result
s.Push(src);
visited.Add(src, true );
// Traverse through the vertices
// until the stack is empty
while (s.Count != 0) {
int n = s.Pop();
// Recur for all the vertices
// adjacent to this vertex
foreach ( var i in adjList[n])
{
// If the vertices are
// not visited
if (visited.ContainsKey(i) == false ) {
dependent.Add(i + 1);
count++;
// Mark the vertex as
// visited
visited.Add(i, true );
// Push the current vertex to
// the stack which stores
// the result
s.Push(i);
}
}
}
// If the vertex has 0 dependency
if (count == 0) {
Console.WriteLine(
"Vertex " + (src + 1)
+ " is not dependent on any vertex." );
return count;
}
Console.Write( "Vertex " + (src + 1)
+ " dependency " );
foreach ( var i in dependent)
{
Console.Write( "-> " + i);
}
Console.WriteLine();
return count;
}
} // Function to find the // dependency of each node public void operations( int [, ] arr, int n, int m)
{ // Creating a new graph
Graph g = new Graph(n);
for ( int i = 0; i < m; i++) {
g.addEdge(arr[i, 0], arr[i, 1], false );
}
int ans = int .MaxValue;
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;
}
}
Console.WriteLine( "Node " + node
+ "has minimum dependency of " + ans);
} // Driver code public static void Main()
{ int n, m;
n = 6;
m = 6;
// Defining the edges of the
// graph
int [, ] arr
= new int [, ] { { 0, 1 }, { 0, 2 }, { 2, 3 },
{ 4, 5 }, { 3, 4 }, { 1, 5 } };
operations(arr, n, m);
} // This code is contributed by ishankhandelwals. |
// Javascript code // Defining the graph class Graph { // Variable to store the
// number of vertices
constructor(v){
this .V = v;
this .adjList = new Array( this .V).fill( new Array());
}
// Adding edges
addEdge(u, v, bidir = true ) {
this .adjList[u].push(v);
if (bidir) {
this .adjList[v].push(u);
}
}
// Performing DFS on each node
dfs(src) {
// Map is used to mark
// the current node as visited
let visited = new Map();
let dependent = [];
let count = 0;
let s = [];
// Push the current vertex
// to the stack which
// stores the result
s.push(src);
visited.set(src, true );
// Traverse through the vertices
// until the stack is empty
while (s.length > 0) {
let n = s.pop();
// Recur for all the vertices
// adjacent to this vertex
this .adjList[n].forEach(i => {
// If the vertices are
// not visited
if (!visited.get(i)) {
dependent.push(i + 1);
count++;
// Mark the vertex as
// visited
visited.set(i, true );
// Push the current vertex to
// the stack which stores
// the result
s.push(i);
}
});
}
// If the vertex has 0 dependency
if (!count) {
console.log(`Vertex ${src + 1} is not dependent on any vertex.`);
return count;
}
console.log(`Vertex ${src + 1} dependency `);
dependent.forEach(i => {
console.log(`-> ${i}`);
});
return count;
}
} // Function to find the // dependency of each node function operations(arr, n, m) {
// Creating a new graph
let g = new Graph(n);
for (let i = 0; i < m; i++) {
g.addEdge(arr[i][0], arr[i][1], false );
}
let ans = Number.MAX_VALUE;
let node = 0;
// Iterating through the graph
for (let i = 0; i < n; i++) {
let c = g.dfs(i);
// Finding the node with
// minimum number of
// dependency
if (c < ans) {
ans = c;
node = i + 1;
}
}
console.log(`Node ${node} has minimum dependency of ${ans}`);
} // Driver code ( function () {
let n = 6, m = 6;
// Defining the edges of the
// graph
let arr = [
[0, 1],
[0, 2],
[2, 3],
[4, 5],
[3, 4],
[1, 5]
];
operations(arr, n, m);
})(); // This code is contributed by ishankhandelwals. |
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
Time Complexity: O(V+E),The time complexity of the above program is O(V+E) where V is the number of vertices and E is the number of edges. We iterate through the graph and perform Depth First Search on each node. This takes O(V+E) time to complete.
Space Complexity: O(V),The space complexity of the above program is O(V). We are creating an adjacency list for the graph which takes O(V) space. We also create a stack and a map to keep track of the nodes which are visited. This takes O(V) space.