Given an N-ary Tree consisting of nodes valued [1, N] and an array value[], where each node i is associated with value[i], the task is to find the maximum of sum of all node values of all levels of the N-ary Tree.
Examples:
Input: N = 8, Edges[][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 4}, {1, 5}, {3, 6}, {6, 7}}, Value[] = {4, 2, 3, -5, -1, 3, -2, 6}
Output: 6
Explanation:
Sum of all nodes of 0th level is 4
Sum of all nodes of 1st level is 0
Sum of all the nodes of 3rd level is 0.
Sum of all the nodes of 4th level is 6.
Therefore, maximum sum of any level of the tree is 6.Input: N = 10, Edges[][2] = {{0, 1}, {0, 2}, {0, 3}, {1, 4}, {1, 5}, {3, 6}, {6, 7}, {6, 8}, {6, 9}}, Value[] = {1, 2, -1, 3, 4, 5, 8, 6, 12, 7}
Output: 25
Approach: This problem can be solved using Level order Traversal. While performing the traversal, process nodes of different levels separately. For every level being processed, compute the sum of nodes at that level and keep track of the maximum sum. Follow the steps:
- Store all the child nodes at the current level in the queue and then count the total sum of nodes at the current level after the level order traversal for a particular level is completed.
- Since the queue now contains all the nodes of the next level, the total sum of nodes in the next level can be easily calculated by traversing the queue.
- Follow the same procedure for the successive levels and update the maximum sum of nodes found at each level.
- After the above steps, print the maximum sum of values stored.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the maximum sum // a level in N-ary treeusing BFS int maxLevelSum( int N, int M,
vector< int > Value,
int Edges[][2])
{ // Stores the edges of the graph
vector< int > adj[N];
// Create Adjacency list
for ( int i = 0; i < M; i++) {
adj[Edges[i][0]].push_back(
Edges[i][1]);
}
// Initialize result
int result = Value[0];
// Stores the nodes of each level
queue< int > q;
// Insert root
q.push(0);
// Perform level order traversal
while (!q.empty()) {
// Count of nodes of the
// current level
int count = q.size();
int sum = 0;
// Traverse the current level
while (count--) {
// Dequeue a node from queue
int temp = q.front();
q.pop();
// Update sum of current level
sum = sum + Value[temp];
// Enqueue the children of
// dequeued node
for ( int i = 0;
i < adj[temp].size(); i++) {
q.push(adj[temp][i]);
}
}
// Update maximum level sum
result = max(sum, result);
}
// Return the result
return result;
} // Driver Code int main()
{ // Number of nodes
int N = 10;
// Edges of the N-ary tree
int Edges[][2] = { { 0, 1 }, { 0, 2 },
{ 0, 3 }, { 1, 4 },
{ 1, 5 }, { 3, 6 },
{ 6, 7 }, { 6, 8 },
{ 6, 9 } };
// Given cost
vector< int > Value = { 1, 2, -1, 3, 4,
5, 8, 6, 12, 7 };
// Function call
cout << maxLevelSum(N, N - 1,
Value, Edges);
return 0;
} |
// Java program for the above approach import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
class GFG{
// Function to find the maximum sum // a level in N-ary treeusing BFS @SuppressWarnings ( "unchecked" )
static int maxLevelSum( int N, int M, int [] Value,
int Edges[][])
{ // Stores the edges of the graph
ArrayList<Integer>[] adj = new ArrayList[N];
for ( int i = 0 ; i < N; i++)
{
adj[i] = new ArrayList<>();
}
// Create Adjacency list
for ( int i = 0 ; i < M; i++)
{
adj[Edges[i][ 0 ]].add(Edges[i][ 1 ]);
}
// Initialize result
int result = Value[ 0 ];
// Stores the nodes of each level
Queue<Integer> q = new LinkedList<>();
// Insert root
q.add( 0 );
// Perform level order traversal
while (!q.isEmpty())
{
// Count of nodes of the
// current level
int count = q.size();
int sum = 0 ;
// Traverse the current level
while (count-- > 0 )
{
// Dequeue a node from queue
int temp = q.poll();
// Update sum of current level
sum = sum + Value[temp];
// Enqueue the children of
// dequeued node
for ( int i = 0 ; i < adj[temp].size(); i++)
{
q.add(adj[temp].get(i));
}
}
// Update maximum level sum
result = Math.max(sum, result);
}
// Return the result
return result;
} // Driver Code public static void main(String[] args)
{ // Number of nodes
int N = 10 ;
// Edges of the N-ary tree
int [][] Edges = { { 0 , 1 }, { 0 , 2 },
{ 0 , 3 }, { 1 , 4 },
{ 1 , 5 }, { 3 , 6 },
{ 6 , 7 }, { 6 , 8 },
{ 6 , 9 } };
// Given cost
int [] Value = { 1 , 2 , - 1 , 3 , 4 ,
5 , 8 , 6 , 12 , 7 };
// Function call
System.out.println(maxLevelSum(N, N - 1 ,
Value, Edges));
} } // This code is contributed by sanjeev2552 |
# Python3 program for the above approach from collections import deque
# Function to find the maximum sum # a level in N-ary treeusing BFS def maxLevelSum(N, M, Value, Edges):
# Stores the edges of the graph
adj = [[] for i in range (N)]
# Create Adjacency list
for i in range (M):
adj[Edges[i][ 0 ]].append(Edges[i][ 1 ])
# Initialize result
result = Value[ 0 ]
# Stores the nodes of each level
q = deque()
# Insert root
q.append( 0 )
# Perform level order traversal
while ( len (q) > 0 ):
# Count of nodes of the
# current level
count = len (q)
sum = 0
# Traverse the current level
while (count):
# Dequeue a node from queue
temp = q.popleft()
# Update sum of current level
sum = sum + Value[temp]
# Enqueue the children of
# dequeued node
for i in range ( len (adj[temp])):
q.append(adj[temp][i])
count - = 1
# Update maximum level sum
result = max ( sum , result)
# Return the result
return result
# Driver Code if __name__ = = '__main__' :
# Number of nodes
N = 10
# Edges of the N-ary tree
Edges = [ [ 0 , 1 ], [ 0 , 2 ],
[ 0 , 3 ], [ 1 , 4 ],
[ 1 , 5 ], [ 3 , 6 ],
[ 6 , 7 ], [ 6 , 8 ],
[ 6 , 9 ] ]
# Given cost
Value = [ 1 , 2 , - 1 , 3 , 4 ,
5 , 8 , 6 , 12 , 7 ]
# Function call
print (maxLevelSum(N, N - 1 ,
Value, Edges))
# This code is contributed by mohit kumar 29 |
// C# program for the // above approach using System;
using System.Collections.Generic;
class GFG{
// Function to find the maximum sum // a level in N-ary treeusing BFS static int maxLevelSum( int N, int M,
int [] Value,
int [,]Edges)
{ // Stores the edges of the graph
List< int >[] adj = new List< int >[N];
for ( int i = 0; i < N; i++)
{
adj[i] = new List< int >();
}
// Create Adjacency list
for ( int i = 0; i < M; i++)
{
adj[Edges[i, 0]].Add(Edges[i, 1]);
}
// Initialize result
int result = Value[0];
// Stores the nodes of each level
Queue< int > q = new Queue< int >();
// Insert root
q.Enqueue(0);
// Perform level order
// traversal
while (q.Count != 0)
{
// Count of nodes of the
// current level
int count = q.Count;
int sum = 0;
// Traverse the current
// level
while (count-- > 0)
{
// Dequeue a node from
// queue
int temp = q.Peek();
q.Dequeue();
// Update sum of current
// level
sum = sum + Value[temp];
// Enqueue the children of
// dequeued node
for ( int i = 0;
i < adj[temp].Count; i++)
{
q.Enqueue(adj[temp][i]);
}
}
// Update maximum level sum
result = Math.Max(sum, result);
}
// Return the result
return result;
} // Driver Code public static void Main(String[] args)
{ // Number of nodes
int N = 10;
// Edges of the N-ary tree
int [,] Edges = {{0, 1}, {0, 2},
{0, 3}, {1, 4},
{1, 5}, {3, 6},
{6, 7}, {6, 8},
{6, 9}};
// Given cost
int [] Value = {1, 2, -1, 3, 4,
5, 8, 6, 12, 7};
// Function call
Console.WriteLine(maxLevelSum(N, N - 1,
Value, Edges));
} } // This code is contributed by Princi Singh |
<script> // JavaScript program for the above approach
// Function to find the maximum sum
// a level in N-ary treeusing BFS
function maxLevelSum(N, M, Value, Edges)
{
// Stores the edges of the graph
let adj = new Array(N);
for (let i = 0; i < N; i++)
{
adj[i] = [];
}
// Create Adjacency list
for (let i = 0; i < M; i++)
{
adj[Edges[i][0]].push(Edges[i][1]);
}
// Initialize result
let result = Value[0];
// Stores the nodes of each level
let q = [];
// Insert root
q.push(0);
// Perform level order
// traversal
while (q.length != 0)
{
// Count of nodes of the
// current level
let count = q.length;
let sum = 0;
// Traverse the current
// level
while (count-- > 0)
{
// Dequeue a node from
// queue
let temp = q[0];
q.shift();
// Update sum of current
// level
sum = sum + Value[temp];
// Enqueue the children of
// dequeued node
for (let i = 0; i < adj[temp].length; i++)
{
q.push(adj[temp][i]);
}
}
// Update maximum level sum
result = Math.max(sum, result);
}
// Return the result
return result;
}
// Number of nodes
let N = 10;
// Edges of the N-ary tree
let Edges = [[0, 1], [0, 2],
[0, 3], [1, 4],
[1, 5], [3, 6],
[6, 7], [6, 8],
[6, 9]];
// Given cost
let Value = [1, 2, -1, 3, 4, 5, 8, 6, 12, 7];
// Function call
document.write(maxLevelSum(N, N - 1, Value, Edges));
</script> |
25
Time Complexity: O(N)
Auxiliary Space: O(N)