具有N个顶点的树的可能数量

给定N个正整数的数组arr [] 。任务是找到可能具有N个顶点的树的数量，以使顶点1和顶点i之间的距离为arr [i] 。这样的树的总数可能非常大，因此以10 ⁹ + 7为模返回答案。

例子：

Input: arr[] = {0, 1, 1, 2}
Output: 2
Explanation: 
Below is the tree:

Input: arr[] = { 0, 3, 2, 1, 2, 2, 1 }
Output: 24

天真的方法：以下是步骤：

1. 如果A ₁ ！= 0且来自A _2的元素。 。 。 _N为0，那么将无法生成树，因此在这种情况下，树的数量为0 。
2. 如果我们将第一个节点作为根节点，则级别1上的所有节点必须是根节点的子节点，级别2上的所有节点必须是1个级别节点的子节点，因此只有一种可能性将它们放置在级别-明智的。
3. 现在令x是节点的数量上的^第i^个电平，y为对节点的数(i + 1)^个电平，以便对水平布置的节点的可能性的数量i和第(i + 1)是x^和y。
4. 因此，树木的计数将是X _{I ^{X(I + 1)，}}其中X _i是节点的数量在^第i^个电平。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
const int mod = 1e9 + 7;
 
// Function to count the total number
// of trees possible
int NumberOfTrees(int arr[], int N)
{
    // Find the max element in the
    // given array
    int maxElement = *max_element(arr, arr + N);
 
    // Level array store the number of
    // nodes on level i initially all
    // values are zero
    int level[maxElement + 1] = { 0 };
    for (int i = 0; i < N; i++) {
 
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1) {
 
        return 0;
    }
 
    // To store the count of trees
    int ans = 1;
 
    // Iterate until maxElement
    for (int i = 0; i < maxElement; i++) {
 
        // Calculate level[i]^level[i+1]
        for (int j = 0; j < level[i + 1]; j++) {
 
            // Update the count of tree
            ans = (ans * level[i]) % mod;
        }
    }
 
    // Return the final count of trees
    return ans;
}
 
// Driver Code
int main()
{
    int N = 7;
 
    // Given array arr[]
    int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function Call
    cout << NumberOfTrees(arr, N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
     
static int mod = (int)(1e9 + 7);
 
// Function to count the total number
// of trees possible
static int NumberOfTrees(int arr[], int N)
{
     
    // Find the max element in the
    // given array
    int maxElement = Arrays.stream(arr).max().getAsInt();
 
    // Level array store the number of
    // nodes on level i initially all
    // values are zero
    int level[] = new int[maxElement + 1];
    for(int i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
 
    // To store the count of trees
    int ans = 1;
 
    // Iterate until maxElement
    for(int i = 0; i < maxElement; i++)
    {
         
        // Calculate level[i]^level[i+1]
        for (int j = 0; j < level[i + 1]; j++)
        {
             
            // Update the count of tree
            ans = (ans * level[i]) % mod;
        }
    }
 
    // Return the final count of trees
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 7;
 
    // Given array arr[]
    int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function call
    System.out.print(NumberOfTrees(arr, N));
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program for the above approach
mod = int(1e9 + 7)
 
# Function to count the total number
# of trees possible
def NumberOfTrees(arr, N):
     
    # Find the max element in the
    # given array
    maxElement = max(arr);
 
    # Level array store the number of
    # Nodes on level i initially all
    # values are zero
    level = [0] * (maxElement + 1);
    for i in range(N):
        level[arr[i]] += 1;
 
    # In this case tree can not be created
    if (arr[0] != 0 or level[0] != 1):
        return 0;
 
    # To store the count of trees
    ans = 1;
 
    # Iterate until maxElement
    for i in range(maxElement):
 
        # Calculate level[i]^level[i+1]
        for j in range(level[i + 1]):
             
            # Update the count of tree
            ans = (ans * level[i]) % mod;
 
    # Return the final count of trees
    return ans;
 
# Driver Code
if __name__ == '__main__':
     
    N = 7;
 
    # Given array arr
    arr = [ 0, 3, 2, 1, 2, 2, 1 ];
 
    # Function call
    print(NumberOfTrees(arr, N));
 
# This code is contributed by shikhasingrajput

C#

// C# program for the above approach
using System;
using System.Linq;
class GFG{
     
static int mod = (int)(1e9 + 7);
 
// Function to count the total number
// of trees possible
static int NumberOfTrees(int []arr, int N)
{
     
    // Find the max element in the
    // given array
    int maxElement = arr.Max();
 
    // Level array store the number of
    // nodes on level i initially all
    // values are zero
    int []level = new int[maxElement + 1];
    for(int i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
 
    // To store the count of trees
    int ans = 1;
 
    // Iterate until maxElement
    for(int i = 0; i < maxElement; i++)
    {
         
        // Calculate level[i]^level[i+1]
        for (int j = 0; j < level[i + 1]; j++)
        {
             
            // Update the count of tree
            ans = (ans * level[i]) % mod;
        }
    }
 
    // Return the readonly count of trees
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 7;
 
    // Given array []arr
    int []arr = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function call
    Console.Write(NumberOfTrees(arr, N));
}
}
 
// This code is contributed by gauravrajput1

Javascript

// JavaScript program for the
// above approach
 
let mod = (1e9 + 7);
   
// Function to count the total number
// of trees possible
function NumberOfTrees(arr, N)
{
       
    // Find the max element in the
    // given array
    let maxElement = Math.max(...arr);
   
    // Level array store the number of
    // nodes on level i initially all
    // values are zero
    let level = Array.from({length: maxElement + 1}, (_, i) => 0);
    for(let i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
   
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
   
    // To store the count of trees
    let ans = 1;
   
    // Iterate until maxElement
    for(let i = 0; i < maxElement; i++)
    {
           
        // Calculate level[i]^level[i+1]
        for (let j = 0; j < level[i + 1]; j++)
        {
               
            // Update the count of tree
            ans = (ans * level[i]) % mod;
        }
    }
   
    // Return the final count of trees
    return ans;
}
// Driver Code
 
    let N = 7;
   
    // Given array arr[]
    let arr = [ 0, 3, 2, 1, 2, 2, 1 ];
   
    // Function call
    document.write(NumberOfTrees(arr, N));
 

输出：

24

时间复杂度： O(N * K)，其中K是级别中的顶点数。
辅助空间： O(N)

高效方法：可以通过使用模幂优化(ans * level [i])的值来优化上述方法。步骤如下：

1. 如果指数是奇数，则将其减去1，然后将基数乘以答案即可。
2. 如果指数为偶数，则将指数除以2，然后将底数平方。
3. 指数变为0时返回1。

下面是上述方法的实现：

C++

// C++ program for the above approach
#include 
using namespace std;
const int mod = 1e9 + 7;
 
// Function that finds the value of x^y
// using Modular Exponentiation
int power(int x, int y)
{
    // Base Case
    if (y == 0)
        return 1;
 
    int p = power(x, y / 2) % mod;
 
    p = (p * p) % mod;
 
    // If y is odd, multiply
    // x with result
    if (y & 1)
        p = (x * p) % mod;
 
    // Return the value
    return p;
}
 
// Function that counts the total
// number of trees possible
int NumberOfTrees(int arr[], int N)
{
 
    // Find the max element in array
    int maxElement
        = *max_element(arr, arr + N);
 
    // Level array store the number nodes
    // on level i initially all values are 0
    int level[maxElement + 1] = { 0 };
 
    for (int i = 0; i < N; i++) {
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1) {
 
        return 0;
    }
 
    int ans = 1;
 
    for (int i = 0; i < maxElement; i++) {
 
        // Calculate level[i]^level[i+1]
        ans = (ans * power(level[i],
                           level[i + 1]))
              % mod;
    }
 
    // Return the final count
    return ans;
}
 
// Driver Code
int main()
{
    int N = 7;
 
    // Given array arr[]
    int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function Call
    cout << NumberOfTrees(arr, N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
 
class GFG{
     
static int mod = (int)1e9 + 7;
 
// Function that finds the value of x^y
// using Modular Exponentiation
static int power(int x, int y)
{
     
    // Base Case
    if (y == 0)
        return 1;
 
    int p = power(x, y / 2) % mod;
 
    p = (p * p) % mod;
 
    // If y is odd, multiply
    // x with result
    if ((y & 1) != 0)
        p = (x * p) % mod;
 
    // Return the value
    return p;
}
 
// Function that counts the total
// number of trees possible
static int NumberOfTrees(int arr[], int N)
{
 
    // Find the max element in array
    int maxElement = Arrays.stream(arr).max().getAsInt();
 
    // Level array store the number nodes
    // on level i initially all values are 0
    int []level = new int[maxElement + 1];
 
    for(int i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
     
    int ans = 1;
 
    for(int i = 0; i < maxElement; i++)
    {
        // Calculate level[i]^level[i+1]
        ans = (ans * power(level[i],
                           level[i + 1])) % mod;
    }
 
    // Return the final count
    return ans;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 7;
 
    // Given array arr[]
    int arr[] = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function call
    System.out.print(NumberOfTrees(arr, N));
}
}
 
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach
mod = int(1e9 + 7)
 
# Function that finds the value of x^y
# using Modular Exponentiation
def power(x, y):
 
    # Base Case
    if(y == 0):
        return 1
 
    p = power(x, y // 2) % mod
 
    p = (p * p) % mod
 
    # If y is odd, multiply
    # x with result
    if(y & 1):
        p = (x * p) % mod
 
    # Return the value
    return p
 
# Function that counts the total
# number of trees possible
def NumberOfTrees(arr, N):
 
    # Find the max element in array
    maxElement = max(arr)
 
    # Level array store the number nodes
    # on level i initially all values are 0
    level = [0] * (maxElement + 1)
 
    for i in range(N):
        level[arr[i]] += 1
 
    # In this case tree can not be created
    if(arr[0] != 0 or level[0] != 1):
        return 0
 
    ans = 1
 
    for i in range(maxElement):
 
        # Calculate level[i]^level[i+1]
        ans = (ans * power(level[i],
                           level[i + 1])) % mod
 
    # Return the final count
    return ans
 
# Driver Code
N = 7
 
# Given Queries
arr = [ 0, 3, 2, 1, 2, 2, 1 ]
 
# Function call
print(NumberOfTrees(arr, N))
 
# This code is contributed by Shivam Singh

C＃

// C# program for the above approach
using System;
using System.Linq;
 
class GFG{
     
static int mod = (int)1e9 + 7;
 
// Function that finds the value of x^y
// using Modular Exponentiation
static int power(int x, int y)
{
     
    // Base Case
    if (y == 0)
        return 1;
 
    int p = power(x, y / 2) % mod;
 
    p = (p * p) % mod;
 
    // If y is odd, multiply
    // x with result
    if ((y & 1) != 0)
        p = (x * p) % mod;
 
    // Return the value
    return p;
}
 
// Function that counts the total
// number of trees possible
static int NumberOfTrees(int []arr, int N)
{
 
    // Find the max element in array
    int maxElement = arr.Max();
 
    // Level array store the number nodes
    // on level i initially all values are 0
    int []level = new int[maxElement + 1];
 
    for(int i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
 
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
     
    int ans = 1;
 
    for(int i = 0; i < maxElement; i++)
    {
         
        // Calculate level[i]^level[i+1]
        ans = (ans * power(level[i],
                           level[i + 1])) % mod;
    }
 
    // Return the readonly count
    return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 7;
 
    // Given array []arr
    int []arr = { 0, 3, 2, 1, 2, 2, 1 };
 
    // Function call
    Console.Write(NumberOfTrees(arr, N));
}
}
 
// This code is contributed by 29AjayKumar

Java脚本

// javascript program for the
// above approach
 
let mod = 1e9 + 7;
  
// Function that finds the value of x^y
// using Modular Exponentiation
function power(x, y)
{
      
    // Base Case
    if (y == 0)
        return 1;
  
    let p = power(x, y / 2) % mod;
  
    p = (p * p) % mod;
  
    // If y is odd, multiply
    // x with result
    if ((y & 1) != 0)
        p = (x * p) % mod;
  
    // Return the value
    return p;
}
  
// Function that counts the total
// number of trees possible
function NumberOfTrees(arr, N)
{
  
    // Find the max element in array
    let maxElement = Math.max(...arr);
  
    // Level array store the number nodes
    // on level i initially all values are 0
    let level = Array(maxElement + 1).fill(0);
  
    for(let i = 0; i < N; i++)
    {
        level[arr[i]]++;
    }
  
    // In this case tree can not be created
    if (arr[0] != 0 || level[0] != 1)
    {
        return 0;
    }
      
    let ans = 1;
  
    for(let i = 0; i < maxElement; i++)
    {
        // Calculate level[i]^level[i+1]
        ans = (ans * power(level[i],
                           level[i + 1])) % mod;
    }
  
    // Return the final count
    return ans;
}
  
// Driver Code
 
    let N = 7;
  
    // Given array arr[]
    let arr = [ 0, 3, 2, 1, 2, 2, 1 ];
  
    // Function call
    document.write(NumberOfTrees(arr, N));
    
   // This code is contributed by decode2207.

输出：

24

时间复杂度： O(N * log K)，其中K是级别中的顶点数。
辅助空间： O(N)