Possible number of Trees having N vertex
Last Updated :
17 May, 2021
Given an array arr[] of N positive integers. The task is to find the number of trees possible having N vertices such that the distance between vertex 1 and vertex i is arr[i]. The total number of such trees can be very large so return the answer with modulo 109 + 7.
Examples:
Input: arr[] = {0, 1, 1, 2}
Output: 2
Explanation:
Below is the tree:
Input: arr[] = { 0, 3, 2, 1, 2, 2, 1 }
Output: 24
Naive Approach: Below are the steps:
- If A1 !=0 and if element from A2 . . . AN is 0 then the tree will not be able to be made so in this case, the count of trees will be 0.
- If we take the first node as root node then all nodes on level 1 must be a child of the root node and all nodes on level 2 must be a child of 1 level nodes, so there is only one possibility to place them in level-wise.
- Now let x be the number of nodes on ith level and y is the number of nodes on (i + 1)th level so the number of possibilities of arranging nodes on level i and (i + 1) is xy.
- Hence, the count of trees will be Xi X(i + 1) where Xi Is the number of nodes in ith level.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int NumberOfTrees( int arr[], int N)
{
int maxElement = *max_element(arr, arr + N);
int level[maxElement + 1] = { 0 };
for ( int i = 0; i < N; i++) {
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1) {
return 0;
}
int ans = 1;
for ( int i = 0; i < maxElement; i++) {
for ( int j = 0; j < level[i + 1]; j++) {
ans = (ans * level[i]) % mod;
}
}
return ans;
}
int main()
{
int N = 7;
int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
cout << NumberOfTrees(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int mod = ( int )(1e9 + 7 );
static int NumberOfTrees( int arr[], int N)
{
int maxElement = Arrays.stream(arr).max().getAsInt();
int level[] = new int [maxElement + 1 ];
for ( int i = 0 ; i < N; i++)
{
level[arr[i]]++;
}
if (arr[ 0 ] != 0 || level[ 0 ] != 1 )
{
return 0 ;
}
int ans = 1 ;
for ( int i = 0 ; i < maxElement; i++)
{
for ( int j = 0 ; j < level[i + 1 ]; j++)
{
ans = (ans * level[i]) % mod;
}
}
return ans;
}
public static void main(String[] args)
{
int N = 7 ;
int arr[] = { 0 , 3 , 2 , 1 , 2 , 2 , 1 };
System.out.print(NumberOfTrees(arr, N));
}
}
|
Python3
mod = int ( 1e9 + 7 )
def NumberOfTrees(arr, N):
maxElement = max (arr);
level = [ 0 ] * (maxElement + 1 );
for i in range (N):
level[arr[i]] + = 1 ;
if (arr[ 0 ] ! = 0 or level[ 0 ] ! = 1 ):
return 0 ;
ans = 1 ;
for i in range (maxElement):
for j in range (level[i + 1 ]):
ans = (ans * level[i]) % mod;
return ans;
if __name__ = = '__main__' :
N = 7 ;
arr = [ 0 , 3 , 2 , 1 , 2 , 2 , 1 ];
print (NumberOfTrees(arr, N));
|
C#
using System;
using System.Linq;
class GFG{
static int mod = ( int )(1e9 + 7);
static int NumberOfTrees( int []arr, int N)
{
int maxElement = arr.Max();
int []level = new int [maxElement + 1];
for ( int i = 0; i < N; i++)
{
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1)
{
return 0;
}
int ans = 1;
for ( int i = 0; i < maxElement; i++)
{
for ( int j = 0; j < level[i + 1]; j++)
{
ans = (ans * level[i]) % mod;
}
}
return ans;
}
public static void Main(String[] args)
{
int N = 7;
int []arr = { 0, 3, 2, 1, 2, 2, 1 };
Console.Write(NumberOfTrees(arr, N));
}
}
|
Javascript
<script>
let mod = (1e9 + 7);
function NumberOfTrees(arr, N)
{
let maxElement = Math.max(...arr);
let level = Array.from({length: maxElement + 1}, (_, i) => 0);
for (let i = 0; i < N; i++)
{
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1)
{
return 0;
}
let ans = 1;
for (let i = 0; i < maxElement; i++)
{
for (let j = 0; j < level[i + 1]; j++)
{
ans = (ans * level[i]) % mod;
}
}
return ans;
}
let N = 7;
let arr = [ 0, 3, 2, 1, 2, 2, 1 ];
document.write(NumberOfTrees(arr, N));
</script>
|
Time Complexity: O(N*K) where K is the number of vertices in a level.
Auxiliary Space: O(N)
Efficient Approach: The above approach can be optimized by optimizing the value of (ans*level[i]) using Modular Exponentiation. Below are the steps:
- If the exponent is odd, make it even by subtracting 1 from it and multiply the base with the answer.
- If the exponent is even, divide the exponent by 2 and square the base.
- Return 1 when the exponent becomes 0.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int power( int x, int y)
{
if (y == 0)
return 1;
int p = power(x, y / 2) % mod;
p = (p * p) % mod;
if (y & 1)
p = (x * p) % mod;
return p;
}
int NumberOfTrees( int arr[], int N)
{
int maxElement
= *max_element(arr, arr + N);
int level[maxElement + 1] = { 0 };
for ( int i = 0; i < N; i++) {
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1) {
return 0;
}
int ans = 1;
for ( int i = 0; i < maxElement; i++) {
ans = (ans * power(level[i],
level[i + 1]))
% mod;
}
return ans;
}
int main()
{
int N = 7;
int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
cout << NumberOfTrees(arr, N);
return 0;
}
|
Java
import java.util.*;
class GFG{
static int mod = ( int )1e9 + 7 ;
static int power( int x, int y)
{
if (y == 0 )
return 1 ;
int p = power(x, y / 2 ) % mod;
p = (p * p) % mod;
if ((y & 1 ) != 0 )
p = (x * p) % mod;
return p;
}
static int NumberOfTrees( int arr[], int N)
{
int maxElement = Arrays.stream(arr).max().getAsInt();
int []level = new int [maxElement + 1 ];
for ( int i = 0 ; i < N; i++)
{
level[arr[i]]++;
}
if (arr[ 0 ] != 0 || level[ 0 ] != 1 )
{
return 0 ;
}
int ans = 1 ;
for ( int i = 0 ; i < maxElement; i++)
{
ans = (ans * power(level[i],
level[i + 1 ])) % mod;
}
return ans;
}
public static void main(String[] args)
{
int N = 7 ;
int arr[] = { 0 , 3 , 2 , 1 , 2 , 2 , 1 };
System.out.print(NumberOfTrees(arr, N));
}
}
|
Python3
mod = int ( 1e9 + 7 )
def power(x, y):
if (y = = 0 ):
return 1
p = power(x, y / / 2 ) % mod
p = (p * p) % mod
if (y & 1 ):
p = (x * p) % mod
return p
def NumberOfTrees(arr, N):
maxElement = max (arr)
level = [ 0 ] * (maxElement + 1 )
for i in range (N):
level[arr[i]] + = 1
if (arr[ 0 ] ! = 0 or level[ 0 ] ! = 1 ):
return 0
ans = 1
for i in range (maxElement):
ans = (ans * power(level[i],
level[i + 1 ])) % mod
return ans
N = 7
arr = [ 0 , 3 , 2 , 1 , 2 , 2 , 1 ]
print (NumberOfTrees(arr, N))
|
C#
using System;
using System.Linq;
class GFG{
static int mod = ( int )1e9 + 7;
static int power( int x, int y)
{
if (y == 0)
return 1;
int p = power(x, y / 2) % mod;
p = (p * p) % mod;
if ((y & 1) != 0)
p = (x * p) % mod;
return p;
}
static int NumberOfTrees( int []arr, int N)
{
int maxElement = arr.Max();
int []level = new int [maxElement + 1];
for ( int i = 0; i < N; i++)
{
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1)
{
return 0;
}
int ans = 1;
for ( int i = 0; i < maxElement; i++)
{
ans = (ans * power(level[i],
level[i + 1])) % mod;
}
return ans;
}
public static void Main(String[] args)
{
int N = 7;
int []arr = { 0, 3, 2, 1, 2, 2, 1 };
Console.Write(NumberOfTrees(arr, N));
}
}
|
Javascript
<script>
let mod = 1e9 + 7;
function power(x, y)
{
if (y == 0)
return 1;
let p = power(x, y / 2) % mod;
p = (p * p) % mod;
if ((y & 1) != 0)
p = (x * p) % mod;
return p;
}
function NumberOfTrees(arr, N)
{
let maxElement = Math.max(...arr);
let level = Array(maxElement + 1).fill(0);
for (let i = 0; i < N; i++)
{
level[arr[i]]++;
}
if (arr[0] != 0 || level[0] != 1)
{
return 0;
}
let ans = 1;
for (let i = 0; i < maxElement; i++)
{
ans = (ans * power(level[i],
level[i + 1])) % mod;
}
return ans;
}
let N = 7;
let arr = [ 0, 3, 2, 1, 2, 2, 1 ];
document.write(NumberOfTrees(arr, N));
</script>
|
Time Complexity: O(N*log K) where K is the number of vertices in a level.
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...