Related Articles

# Sum of minimum element at each depth of a given non cyclic graph

• Difficulty Level : Medium
• Last Updated : 02 Jul, 2021

Given a non-cyclic graph having V nodes and E edges and a source node S, the task is to calculate the sum of the minimum element at each level from source node S in the given graph.
Examples:

Input: S = 0, Below is the given graph

Output:
Explanation:
There is only one node at depth 0 i.e. 0.
At depth 1 there are 3 nodes 1, 2, 3, and minimum of them is 1.
At depth 2 there are another 3 nodes i.e. 6, 4, 5, and a minimum of them is 4.
So the sum of minimum element at each depth is 0 + 1 + 4 = 5.
Input: S = 2, Below is the given graph

Output:
Explanation:
At depth 0 only 1 node exists i.e. 2.
At depth 1 minimum element is 0.
At depth 2 minimum element is 1.
At depth 3 minimum element is 5
So the sum of minimum element at each depth is 2 + 0 + 1 + 5 = 8.

Approach: The idea is to use DFS Traversal. Below are the steps:

1. Initialise an array(say arr[]) to store the minimum element at each level.
2. Start the DFS Traversal from the given source node S with a variable depth(initially 0).
3. Update the minimum value of current depth in the array arr[].
4. Recursively recurr for child node with incrementing the value of depth from the previous recursive call such that the minimum value at corresponding depth can be updated accordingly.
5. After the above steps the sum of values stored in arr[] is the required total sum.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to add an edge in a graph``void` `addEdge(vector<``int``> adj[],``            ``int` `u, ``int` `v)``{``    ``adj[u].push_back(v);``    ``adj[v].push_back(u);``}` `// Variable to store depth of graph``int` `max_depth = 0;` `// Function to know the depth of graph``void` `find_depth(vector<``int``> adj[],``                ``vector<``bool``>& visited,``                ``int` `start, ``int` `depth)``{``    ``// Mark the node start as true``    ``visited[start] = ``true``;` `    ``// Update the maximum depth``    ``max_depth = max(max_depth, depth);` `    ``// Recurr for the child node of``    ``// start node``    ``for` `(``auto` `i : adj[start]) {``        ``if` `(!visited[i])``            ``find_depth(adj, visited,``                    ``i, depth + 1);``    ``}``}` `// Function to calculate min value``// at every depth``void` `dfs(vector<``int``> adj[], ``int` `start,``        ``vector<``bool``>& visited,``        ``vector<``int``>& store_min_elements,``        ``int` `depth)``{``    ``// marking already visited``    ``// vertices as true``    ``visited[start] = ``true``;` `    ``// Store the min value for``    ``// every depth``    ``store_min_elements[depth]``        ``= min(store_min_elements[depth],``            ``start);` `    ``// Traverse Child node of start node``    ``for` `(``auto` `i : adj[start]) {``        ``if` `(!visited[i])``            ``dfs(adj, i, visited,``                ``store_min_elements,``                ``depth + 1);``    ``}``}` `// Function to calculate the sum``void` `minSum_depth(vector<``int``> adj[],``                ``int` `start,``                ``int` `total_nodes)``{``    ``vector<``bool``> visited(total_nodes,``                        ``false``);` `    ``// Calling function to know``    ``// the depth of graph``    ``find_depth(adj, visited,``            ``start, 0);` `    ``// Set all value of visited``    ``// to false again``    ``fill(visited.begin(),``        ``visited.end(), ``false``);` `    ``// Declaring vector of``    ``// "max_depth + 1" size to``    ``// store min values at every``    ``// depth initialise vector``    ``// with max number``    ``vector<``int``> store_min_elements(``        ``max_depth + 1, INT_MAX);` `    ``// Calling dfs function for``    ``// calculation of min element``    ``// at every depth``    ``dfs(adj, start, visited,``        ``store_min_elements, 0);` `    ``// Variable to store sum of``    ``// all min elements``    ``int` `min_sum = 0;` `    ``// Calculation of minimum sum``    ``for` `(``int` `i = 0;``        ``i < store_min_elements.size();``        ``i++) {``        ``min_sum += store_min_elements[i];``    ``}` `    ``// Print the minimum sum``    ``cout << min_sum << endl;``}` `// Driver Code``int` `main()``{``    ``// Given Nodes and start node``    ``int` `V = 7, start = 0;` `    ``// Given graph``    ``vector<``int``> adj[V];``    ``addEdge(adj, 0, 1);``    ``addEdge(adj, 0, 2);``    ``addEdge(adj, 0, 3);``    ``addEdge(adj, 1, 6);``    ``addEdge(adj, 2, 4);``    ``addEdge(adj, 3, 5);` `    ``// Function Call``    ``minSum_depth(adj, start, V);``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `Graph{``    ` `public` `static` `int` `V;` `// Variable to store depth of graph``public` `static` `int` `max_depth = ``0``;``private` `static` `LinkedList adj[];` `@SuppressWarnings``(``"unchecked"``)``Graph(``int` `v)``{``    ``V = v;``    ``adj = ``new` `LinkedList[v];``    ``for``(``int` `i = ``0``; i < v; ++i)``        ``adj[i] = ``new` `LinkedList();``}` `static` `void` `addEdge(``int` `v, ``int` `w)``{``    ``adj[v].add(w);``}` `static` `void` `find_depth(``boolean` `visited[],``                       ``int` `start, ``int` `depth)``{``    ` `    ``// Mark the node start as true``    ``visited[start] = ``true``;` `    ``// Update the maximum depth``    ``max_depth = Math.max(max_depth, depth);` `    ``// Recurr for the child node of``    ``// start node``    ``Iterator i = adj[start].listIterator();``    ``while` `(i.hasNext())``    ``{``        ``int` `n = i.next();``        ``if` `(!visited[n])``            ``find_depth(visited, n, depth + ``1``);``    ``}``}` `// Function to calculate min value``// at every depth``static` `void` `dfs(``int` `start, ``boolean` `visited[],``                ``int` `store_min_elements[],``                ``int` `depth)``{``    ` `    ``// Marking already visited``    ``// vertices as true``    ``visited[start] = ``true``;` `    ``// Store the min value for``    ``// every depth``    ``store_min_elements[depth] = Math.min(``        ``store_min_elements[depth], start);` `    ``// Traverse Child node of start node``    ``Iterator i = adj[start].listIterator();``    ``while` `(i.hasNext())``    ``{``        ``int` `n = i.next();``        ``if` `(!visited[n])``            ``dfs(n, visited, store_min_elements,``                ``depth + ``1``);``    ``}``}` `// Function to calculate the sum``static` `void` `minSum_depth(``int` `start, ``int` `total_nodes)``{``    ``boolean` `visited[] = ``new` `boolean``[total_nodes];` `    ``// Calling function to know``    ``// the depth of graph``    ``find_depth(visited, start, ``0``);` `    ``// Set all value of visited``    ``// to false again``    ``Arrays.fill(visited, ``false``);` `    ``// Declaring vector of``    ``// "max_depth + 1" size to``    ``// store min values at every``    ``// depth initialise vector``    ``// with max number``    ``int` `store_min_elements[] = ``new` `int``[max_depth + ``1``];``    ``Arrays.fill(store_min_elements,``                ``Integer.MAX_VALUE);``                ` `    ``// Calling dfs function for``    ``// calculation of min element``    ``// at every depth``    ``dfs(start, visited,``        ``store_min_elements, ``0``);` `    ``// Variable to store sum of``    ``// all min elements``    ``int` `min_sum = ``0``;` `    ``// Calculation of minimum sum``    ``for``(``int` `i = ``0``;``            ``i < store_min_elements.length;``            ``i++)``    ``{``        ``min_sum += store_min_elements[i];``    ``}` `    ``// Print the minimum sum``    ``System.out.println(min_sum);``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ` `    ``// Given Nodes and start node``    ``V = ``7``;``    ``int` `start = ``0``;``    ` `    ``Graph g = ``new` `Graph(V);``    ` `    ``// Given graph``    ``g.addEdge(``0``, ``1``);``    ``g.addEdge(``0``, ``2``);``    ``g.addEdge(``0``, ``3``);``    ``g.addEdge(``1``, ``6``);``    ``g.addEdge(``2``, ``4``);``    ``g.addEdge(``3``, ``5``);` `    ``// Function call``    ``minSum_depth( start, V);``}``}` `// This code is contributed by Stream_Cipher`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `Graph{``    ` `private` `static` `int` `V;``private` `static` `int` `start;` `// Variable to store depth of graph``public` `static` `int` `max_depth = 0;``private` `static` `List<``int``>[] adj;` `Graph(``int` `v)``{``    ``V = v;``    ``adj = ``new` `List<``int``>[v];``    ``for``(``int` `i = 0; i < v; ++i)``        ``adj[i] = ``new` `List<``int``>();``}` `// Function to add an edge in a graph``void` `addEdge(``int` `v, ``int` `w)``{``    ``adj[v].Add(w);``}` `// Function to know the depth of graph``void` `find_depth(``bool` `[]visited,``                ``int` `start, ``int` `depth)``{``    ` `    ``// Mark the node start as true``    ``visited[start] = ``true``;` `    ``// Update the maximum depth``    ``max_depth = Math.Max(max_depth, depth);` `    ``// Recurr for the child node of``    ``// start node``    ``List<``int``> vList = adj[start];``    ``foreach``(``var` `n ``in` `vList)``    ``{``        ``if` `(!visited[n])``            ``find_depth(visited, n,``                       ``depth + 1);``    ``}``}` `// Function to calculate min value``// at every depth``void` `dfs(``int` `start, ``bool` `[]visited,``         ``int` `[]store_min_elements,``         ``int` `depth)``{``    ` `    ``// Marking already visited``    ``// vertices as true``    ``visited[start] = ``true``;` `    ``// Store the min value for``    ``// every depth``    ``store_min_elements[depth] = Math.Min(``        ``store_min_elements[depth], start);` `    ``// Traverse Child node of start node``    ``List<``int``> vList = adj[start];``    ``foreach``(``var` `n ``in` `vList)``    ``{``        ``if` `(!visited[n])``            ``dfs(n, visited,``                ``store_min_elements,``                ``depth + 1);``    ``}``}` `// Function to calculate the sum``void` `minSum_depth(``int` `start, ``int` `total_nodes)``{``    ``bool` `[]visited = ``new` `bool``[total_nodes];` `    ``// Calling function to know``    ``// the depth of graph``    ``find_depth(visited, start, 0);` `    ``// Set all value of visited``    ``// to false again``    ``for``(``int` `i = 0; i < visited.Length; i++)``    ``{``        ``visited[i] = ``false``;``    ``}` `    ``// Declaring vector of "max_depth + 1"``    ``// size to store min values at every``    ``// depth initialise vector with max number``    ``int` `[]store_min_elements = ``new` `int` `[max_depth + 1];``    ``for``(``int` `i = 0;``            ``i < store_min_elements.Length;``            ``i++)``    ``{``        ``store_min_elements[i] = Int32.MaxValue;``    ``}``    ` `    ``// Calling dfs function for``    ``// calculation of min element``    ``// at every depth``    ``dfs(start, visited, store_min_elements, 0);` `    ``// Variable to store sum of``    ``// all min elements``    ``int` `min_sum = 0;``    ` `    ``// Calculation of minimum sum``    ``for``(``int` `i = 0;``            ``i < store_min_elements.Length;``            ``i++)``    ``{``        ``min_sum += store_min_elements[i];``    ``}` `    ``// Print the minimum sum``    ``Console.WriteLine(min_sum);``}` `// Driver Code``public` `static` `void` `Main()``{``    ` `    ``// Given Nodes and start node``    ``V = 7;``    ``start = 0;``    ``Graph g = ``new` `Graph(V);``    ` `    ``// Given graph``    ``g.addEdge(0, 1);``    ``g.addEdge(0, 2);``    ``g.addEdge(0, 3);``    ``g.addEdge(1, 6);``    ``g.addEdge(2, 4);``    ``g.addEdge(3, 5);` `    ``// Function call``    ``g.minSum_depth(start , V);``}``}` `// This code is contributed by Stream_Cipher`

## Javascript

 ``
Output:
`5`

Time Complexity: O(V + E)
Auxillary Space: 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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up