Skip to content
Related Articles
Count of subtrees possible from an N-ary Tree
• Last Updated : 21 May, 2021

Given an N-ary tree consisting of N nodes having values 0 to (N – 1), the task is to find the total number of subtrees present in the given tree. Since the count can be very large, so print the count modulo 1000000007.

Examples:

Input: N = 3
0
/
1
/
2
Output: 7
Explanation:
The total number of subtrees nodes are {}, {0}, {1}, {2}, {0, 1}, {1, 2}, {0, 1, 2}.

Input: N = 2
0
/
1
Output: 4

Approach: The approach for solving the given problem is to perform DFS Traversal on the given tree. Follow the steps below to solve the problem:

• Initialize a variable, say count as 0, to store the count of the total number of subtrees present in the given tree.
• Declare a function DFS(int src, int parent) to count the number of subtrees for the node src and perform the following operations:
• Initialize a variable, say res as 1.
• Traverse the adjacency list of the current node and if the node in the adjacency list, say X is not the same as the parent node, then recursively call the DFS function for the node X and node src as the parent node as DFS(X, src).
• Let the value returned to the above recursive call is value, then update the value of res as (res * (value + 1)) % (109 + 7).
• Update the value of count as (count + res) % (109 + 7).
• Return the value of res from each recursive call.
• Call the function DFS() for the root node 1.
• After completing the above steps, print the value of count as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach` `#include ``#define MAX 300004``using` `namespace` `std;` `// Adjacency list to``// represent the graph``vector<``int``> graph[MAX];``int` `mod = 1e9 + 7;` `// Stores the count of subtrees``// possible from given N-ary Tree``int` `ans = 0;` `// Utility function to count the number of``// subtrees possible from given N-ary Tree``int` `countSubtreesUtil(``int` `cur, ``int` `par)``{``    ``// Stores the count of subtrees``    ``// when cur node is the root``    ``int` `res = 1;` `    ``// Traverse the adjacency list``    ``for` `(``int` `i = 0;``         ``i < graph[cur].size(); i++) {` `        ``// Iterate over every ancestor``        ``int` `v = graph[cur][i];` `        ``if` `(v == par)``            ``continue``;` `        ``// Calculate product of the number``        ``// of subtrees for each child node``        ``res = (res``               ``* (countSubtreesUtil(``                      ``v, cur)``                  ``+ 1))``              ``% mod;``    ``}` `    ``// Update the value of ans``    ``ans = (ans + res) % mod;` `    ``// Return the resultant count``    ``return` `res;``}` `// Function to count the number of``// subtrees in the given tree``void` `countSubtrees(``int` `N,``                   ``vector >& adj)``{``    ``// Initialize an adjacency matrix``    ``for` `(``int` `i = 0; i < N - 1; i++) {``        ``int` `a = adj[i].first;``        ``int` `b = adj[i].second;` `        ``// Add the edges``        ``graph[a].push_back(b);``        ``graph[b].push_back(a);``    ``}` `    ``// Function Call to count the``    ``// number of subtrees possible``    ``countSubtreesUtil(1, 1);` `    ``// Print count of subtrees``    ``cout << ans + 1;``}` `// Driver Code``int` `main()``{``    ``int` `N = 3;` `    ``vector > adj``        ``= { { 0, 1 }, { 1, 2 } };` `    ``countSubtrees(N, adj);` `    ``return` `0;``}`

## Java

 `// Java program of above approach``import` `java.util.*;` `class` `GFG{``    ` `static` `int` `MAX = ``300004``;` `// Adjacency list to``// represent the graph``static` `ArrayList> graph;``static` `long` `mod = (``long``)1e9 + ``7``;`` ` `// Stores the count of subtrees``// possible from given N-ary Tree``static` `int` `ans = ``0``;`` ` `// Utility function to count the number of``// subtrees possible from given N-ary Tree``static` `int` `countSubtreesUtil(``int` `cur, ``int` `par)``{``    ` `    ``// Stores the count of subtrees``    ``// when cur node is the root``    ``int` `res = ``1``;`` ` `    ``// Traverse the adjacency list``    ``for``(``int` `i = ``0``;``            ``i < graph.get(cur).size(); i++)``    ``{`` ` `        ``// Iterate over every ancestor``        ``int` `v = graph.get(cur).get(i);`` ` `        ``if` `(v == par)``            ``continue``;`` ` `        ``// Calculate product of the number``        ``// of subtrees for each child node``        ``res = (``int``)((res * (countSubtreesUtil(``                 ``v, cur) + ``1``)) % mod);``    ``}`` ` `    ``// Update the value of ans``    ``ans = (``int``)((ans + res) % mod);`` ` `    ``// Return the resultant count``    ``return` `res;``}`` ` `// Function to count the number of``// subtrees in the given tree``static` `void` `countSubtrees(``int` `N, ``int``[][] adj)``{``    ` `    ``// Initialize an adjacency matrix``    ``for``(``int` `i = ``0``; i < N - ``1``; i++)``    ``{``        ``int` `a = adj[i][``0``];``        ``int` `b = adj[i][``1``];`` ` `        ``// Add the edges``        ``graph.get(a).add(b);``        ``graph.get(b).add(a);``    ``}`` ` `    ``// Function Call to count the``    ``// number of subtrees possible``    ``countSubtreesUtil(``1``, ``1``);`` ` `    ``// Print count of subtrees``   ``System.out.println(ans + ``1``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``3``;``    ` `    ``int``[][] adj = { { ``0``, ``1` `}, { ``1``, ``2` `} };``    ` `    ``graph = ``new` `ArrayList<>();``    ` `    ``for``(``int` `i = ``0``; i < MAX; i++)``        ``graph.add(``new` `ArrayList<>());``    ` `    ``countSubtrees(N, adj);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program of the above approach``MAX` `=` `300004` `# Adjacency list to``# represent the graph``graph ``=` `[[] ``for` `i ``in` `range``(``MAX``)]``mod ``=` `10``*``*``9` `+` `7` `# Stores the count of subtrees``# possible from given N-ary Tree``ans ``=` `0` `# Utility function to count the number of``# subtrees possible from given N-ary Tree``def` `countSubtreesUtil(cur, par):``    ``global` `mod, ans``    ` `    ``# Stores the count of subtrees``    ``# when cur node is the root``    ``res ``=` `1` `    ``# Traverse the adjacency list``    ``for` `i ``in` `range``(``len``(graph[cur])):` `        ``# Iterate over every ancestor``        ``v ``=` `graph[cur][i]` `        ``if` `(v ``=``=` `par):``            ``continue` `        ``# Calculate product of the number``        ``# of subtrees for each child node``        ``res ``=` `(res ``*` `(countSubtreesUtil(v, cur)``+` `1``)) ``%` `mod` `    ``# Update the value of ans``    ``ans ``=` `(ans ``+` `res) ``%` `mod` `    ``# Return the resultant count``    ``return` `res` `# Function to count the number of``# subtrees in the given tree``def` `countSubtrees(N, adj):``  ` `    ``# Initialize an adjacency matrix``    ``for` `i ``in` `range``(N``-``1``):``        ``a ``=` `adj[i][``0``]``        ``b ``=` `adj[i][``1``]` `        ``# Add the edges``        ``graph[a].append(b)``        ``graph[b].append(a)` `    ``# Function Call to count the``    ``# number of subtrees possible``    ``countSubtreesUtil(``1``, ``1``)` `    ``# Prcount of subtrees``    ``print` `(ans ``+` `1``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `3` `    ``adj ``=` `[ [ ``0``, ``1` `], [ ``1``, ``2` `] ]` `    ``countSubtrees(N, adj)` `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program of above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG``{` `    ``static` `int` `MAX = 300004;` `    ``// Adjacency list to``    ``// represent the graph``    ``static` `List> graph;``    ``static` `long` `mod = (``long``) 1e9 + 7;` `    ``// Stores the count of subtrees``    ``// possible from given N-ary Tree``    ``static` `int` `ans = 0;` `    ``// Utility function to count the number of``    ``// subtrees possible from given N-ary Tree``    ``static` `int` `countSubtreesUtil(``int` `cur, ``int` `par) {` `        ``// Stores the count of subtrees``        ``// when cur node is the root``        ``int` `res = 1;` `        ``// Traverse the adjacency list``        ``for` `(``int` `i = 0; i < graph[cur].Count; i++) {` `            ``// Iterate over every ancestor``            ``int` `v = graph[cur][i];` `            ``if` `(v == par)``                ``continue``;` `            ``// Calculate product of the number``            ``// of subtrees for each child node``            ``res = (``int``) ((res * (countSubtreesUtil(v, cur) + 1)) % mod);``        ``}` `        ``// Update the value of ans``        ``ans = (``int``) ((ans + res) % mod);` `        ``// Return the resultant count``        ``return` `res;``    ``}` `    ``// Function to count the number of``    ``// subtrees in the given tree``    ``static` `void` `countSubtrees(``int` `N, ``int``[,] adj) {` `        ``// Initialize an adjacency matrix``        ``for` `(``int` `i = 0; i < N - 1; i++) {``            ``int` `a = adj[i,0];``            ``int` `b = adj[i,1];` `            ``// Add the edges``            ``graph[a].Add(b);``            ``graph[b].Add(a);``        ``}` `        ``// Function Call to count the``        ``// number of subtrees possible``        ``countSubtreesUtil(1, 1);` `        ``// Print count of subtrees``        ``Console.WriteLine(ans + 1);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args) {``        ``int` `N = 3;` `        ``int``[,] adj = { { 0, 1 }, { 1, 2 } };` `        ``graph = ``new` `List>();` `        ` `for` `(``int` `i = 0; i < MAX; i++)``            ``graph.Add(``new` `List<``int``>());``        ``countSubtrees(N, adj);``    ``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
`7`

Time Complexity: O(N)
Auxiliary Space: O(N)

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 industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up