Given a generic tree such that each node has a value associated with it, the task is to find the largest number of connected nodes having the same value in the tree. Two nodes are connected if one node is a child of another node.
Example:
Input: Tree in the image below
Output: 4
Explanation: The largest group of connected nodes are of the value 3 with number of nodes equal to 4.Input: Tree in the image below
Output: 2
Approach: The given problem can be solved by using the post-order traversal. The idea is to check if the child node has the same value as its parent node and add 1 to the answer returned from the child node. Below steps can be followed to solve the problem:
- Apply post-order traversal on the N-ary tree:
- If the root has no children then return 1 to the parent
- Add all the answers returned from the children nodes whose value is same as current node
- Update the maximum number of connected nodes
- Return the maximum number of connected nodes as the answer
Below is the implementation of the above approach:
// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;
class Node {
public:
vector<Node*> children;
int val;
// constructor
Node(int v)
{
val = v;
children = {};
}
};
// Post order traversal function
// to calculate the largest group
// of connected nodes
int postOrder(Node* root, int maxi[])
{
// If the current node has no
// children then return 1
if (root->children.size() == 0)
return 1;
// Initialize a variable sum to
// calculate largest group connected
// to current node with same value
// as current node
int sum = 1;
// Iterate through all neighbors
for (Node* child : root->children) {
// Get the value from children
int nodes = postOrder(child, maxi);
// If child node value is same as
// current node then add the
// returned value to sum
if (child->val == root->val)
sum += nodes;
}
// Update maximum connected
// nodes if sum is greater
maxi[0] = max(maxi[0], sum);
// Return the connected group
// to the current node
return sum;
}
// Function to find the largest
// number of nodes in a tree
int largestGroup(Node* root)
{
// Base case
if (root == NULL)
return 0;
// Initialize a variable max
// to calculate largest group
int maxi[1];
// Post-order traversal
postOrder(root, maxi);
// Return the answer
return maxi[0];
}
// Driver code
int main()
{
// Initialize the tree
Node* three1 = new Node(3);
Node* three2 = new Node(3);
Node* three3 = new Node(3);
Node* three4 = new Node(3);
Node* two1 = new Node(2);
Node* two2 = new Node(2);
Node* two3 = new Node(2);
Node* two4 = new Node(2);
Node* four1 = new Node(4);
Node* four2 = new Node(4);
Node* four3 = new Node(4);
Node* one1 = new Node(1);
Node* one2 = new Node(1);
Node* one3 = new Node(1);
Node* one4 = new Node(1);
three2->children.push_back(two1);
three2->children.push_back(three1);
three2->children.push_back(three3);
four1->children.push_back(four2);
four1->children.push_back(four3);
two2->children.push_back(one1);
two2->children.push_back(one2);
two2->children.push_back(two3);
one3->children.push_back(one4);
one3->children.push_back(two4);
three4->children.push_back(three2);
three4->children.push_back(four1);
three4->children.push_back(two2);
three4->children.push_back(one3);
// Call the function
// and print the result
cout << (largestGroup(three4));
}
// This code is contributed by Potta Lokesh
// Java implementation for the above approach
import java.io.*;
import java.util.*;
class GFG {
static class Node {
List<Node> children;
int val;
// constructor
public Node(int val)
{
this.val = val;
children = new ArrayList<>();
}
}
// Function to find the largest
// number of nodes in a tree
public static int largestGroup(Node root)
{
// Base case
if (root == null)
return 0;
// Initialize a variable max
// to calculate largest group
int[] max = new int[1];
// Post-order traversal
postOrder(root, max);
// Return the answer
return max[0];
}
// Post order traversal function
// to calculate the largest group
// of connected nodes
public static int postOrder(
Node root, int[] max)
{
// If the current node has no
// children then return 1
if (root.children.size() == 0)
return 1;
// Initialize a variable sum to
// calculate largest group connected
// to current node with same value
// as current node
int sum = 1;
// Iterate through all neighbors
for (Node child : root.children) {
// Get the value from children
int nodes = postOrder(child, max);
// If child node value is same as
// current node then add the
// returned value to sum
if (child.val == root.val)
sum += nodes;
}
// Update maximum connected
// nodes if sum is greater
max[0] = Math.max(max[0], sum);
// Return the connected group
// to the current node
return sum;
}
// Driver code
public static void main(String[] args)
{
// Initialize the tree
Node three1 = new Node(3);
Node three2 = new Node(3);
Node three3 = new Node(3);
Node three4 = new Node(3);
Node two1 = new Node(2);
Node two2 = new Node(2);
Node two3 = new Node(2);
Node two4 = new Node(2);
Node four1 = new Node(4);
Node four2 = new Node(4);
Node four3 = new Node(4);
Node one1 = new Node(1);
Node one2 = new Node(1);
Node one3 = new Node(1);
Node one4 = new Node(1);
three2.children.add(two1);
three2.children.add(three1);
three2.children.add(three3);
four1.children.add(four2);
four1.children.add(four3);
two2.children.add(one1);
two2.children.add(one2);
two2.children.add(two3);
one3.children.add(one4);
one3.children.add(two4);
three4.children.add(three2);
three4.children.add(four1);
three4.children.add(two2);
three4.children.add(one3);
// Call the function
// and print the result
System.out.println(
largestGroup(three4));
}
}
# Python code for the above approach
class Node:
# constructor
def __init__(self, v):
self.val = v;
self.children = [];
# Post order traversal function
# to calculate the largest group
# of connected nodes
def postOrder(root, maxi):
# If the current node has no
# children then return 1
if (len(root.children) == 0):
return 1;
# Initialize a variable sum to
# calculate largest group connected
# to current node with same value
# as current node
sum = 1;
# Iterate through all neighbors
for child in root.children:
# Get the value from children
nodes = postOrder(child, maxi);
# If child node value is same as
# current node then add the
# returned value to sum
if (child.val == root.val):
sum += nodes;
# Update maximum connected
# nodes if sum is greater
maxi[0] = max(maxi[0], sum);
# Return the connected group
# to the current node
return sum;
# Function to find the largest
# number of nodes in a tree
def largestGroup(root):
# Base case
if (root == None):
return 0;
# Initialize a variable max
# to calculate largest group
maxi = [0];
# Post-order traversal
postOrder(root, maxi);
# Return the answer
return maxi[0];
# Driver code
# Initialize the tree
three1 = Node(3);
three2 = Node(3);
three3 = Node(3);
three4 = Node(3);
two1 = Node(2);
two2 = Node(2);
two3 = Node(2);
two4 = Node(2);
four1 = Node(4);
four2 = Node(4);
four3 = Node(4);
one1 = Node(1);
one2 = Node(1);
one3 = Node(1);
one4 = Node(1);
three2.children.append(two1);
three2.children.append(three1);
three2.children.append(three3);
four1.children.append(four2);
four1.children.append(four3);
two2.children.append(one1);
two2.children.append(one2);
two2.children.append(two3);
one3.children.append(one4);
one3.children.append(two4);
three4.children.append(three2);
three4.children.append(four1);
three4.children.append(two2);
three4.children.append(one3);
# Call the function
# and print the result
print((largestGroup(three4)));
# This code is contributed by gfgking
// C# implementation for the above approach
using System;
using System.Collections.Generic;
// Class representing a Node of an N-ary tree
public class Node
{
public int val;
public List<Node> children;
// Constructor to create a Node
public Node(int vall)
{
val = vall;
children = new List<Node>();
}
}
class GFG {
// Function to find the largest
// number of nodes in a tree
public static int largestGroup(Node root)
{
// Base case
if (root == null)
return 0;
// Initialize a variable max
// to calculate largest group
int[] max = new int[1];
// Post-order traversal
postOrder(root, max);
// Return the answer
return max[0];
}
// Post order traversal function
// to calculate the largest group
// of connected nodes
public static int postOrder(
Node root, int[] max)
{
// If the current node has no
// children then return 1
if (root.children.Count == 0)
return 1;
// Initialize a variable sum to
// calculate largest group connected
// to current node with same value
// as current node
int sum = 1;
// Iterate through all neighbors
foreach (Node child in root.children) {
// Get the value from children
int nodes = postOrder(child, max);
// If child node value is same as
// current node then Add the
// returned value to sum
if (child.val == root.val)
sum += nodes;
}
// Update maximum connected
// nodes if sum is greater
max[0] = Math.Max(max[0], sum);
// Return the connected group
// to the current node
return sum;
}
// Driver code
static public void Main (){
// Initialize the tree
Node three1 = new Node(3);
Node three2 = new Node(3);
Node three3 = new Node(3);
Node three4 = new Node(3);
Node two1 = new Node(2);
Node two2 = new Node(2);
Node two3 = new Node(2);
Node two4 = new Node(2);
Node four1 = new Node(4);
Node four2 = new Node(4);
Node four3 = new Node(4);
Node one1 = new Node(1);
Node one2 = new Node(1);
Node one3 = new Node(1);
Node one4 = new Node(1);
three2.children.Add(two1);
three2.children.Add(three1);
three2.children.Add(three3);
four1.children.Add(four2);
four1.children.Add(four3);
two2.children.Add(one1);
two2.children.Add(one2);
two2.children.Add(two3);
one3.children.Add(one4);
one3.children.Add(two4);
three4.children.Add(three2);
three4.children.Add(four1);
three4.children.Add(two2);
three4.children.Add(one3);
// Call the function
// and print the result
Console.WriteLine(
largestGroup(three4));
}
}
// This code is contributed
// by Shubham Singh
<script>
// Javascript code for the above approach
class Node {
// constructor
constructor(v) {
this.val = v;
this.children = [];
}
};
// Post order traversal function
// to calculate the largest group
// of connected nodes
function postOrder(root, maxi) {
// If the current node has no
// children then return 1
if (root.children.length == 0)
return 1;
// Initialize a variable sum to
// calculate largest group connected
// to current node with same value
// as current node
let sum = 1;
// Iterate through all neighbors
for (child of root.children) {
// Get the value from children
let nodes = postOrder(child, maxi);
// If child node value is same as
// current node then add the
// returned value to sum
if (child.val == root.val)
sum += nodes;
}
// Update maximum connected
// nodes if sum is greater
maxi[0] = Math.max(maxi[0], sum);
// Return the connected group
// to the current node
return sum;
}
// Function to find the largest
// number of nodes in a tree
function largestGroup(root) {
// Base case
if (root == null)
return 0;
// Initialize a variable max
// to calculate largest group
let maxi = [0];
// Post-order traversal
postOrder(root, maxi);
// Return the answer
return maxi[0];
}
// Driver code
// Initialize the tree
let three1 = new Node(3);
let three2 = new Node(3);
let three3 = new Node(3);
let three4 = new Node(3);
let two1 = new Node(2);
let two2 = new Node(2);
let two3 = new Node(2);
let two4 = new Node(2);
let four1 = new Node(4);
let four2 = new Node(4);
let four3 = new Node(4);
let one1 = new Node(1);
let one2 = new Node(1);
let one3 = new Node(1);
let one4 = new Node(1);
three2.children.push(two1);
three2.children.push(three1);
three2.children.push(three3);
four1.children.push(four2);
four1.children.push(four3);
two2.children.push(one1);
two2.children.push(one2);
two2.children.push(two3);
one3.children.push(one4);
one3.children.push(two4);
three4.children.push(three2);
three4.children.push(four1);
three4.children.push(two2);
three4.children.push(one3);
// Call the function
// and print the result
document.write((largestGroup(three4)));
// This code is contributed by gfgking
</script>
Output:
4
Time Complexity: O(N), where N is the number of nodes in the tree
Auxiliary Space: O(H), H is the height of the tree
