# Number of full binary trees such that each node is product of its children

Given an array of n integers, each integer is greater than 1. The task is to find the number of Full binary tree from the given integers, such that each non-node leaf node value is the product of its children value. Given that, each integer can be used multiple times in a full binary tree.
Examples:

```Input : arr[] = { 2, 3, 4, 6 }.
Output : 7
There can be 7 full binary tree with the given product property.

// Four trees with single nodes
2  3  4  6

// Three trees with three nodes
4   ,
/ \
2   2

6    ,
/ \
2   3

6
/ \
3   2
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

We find maximum value in given array and create an array to store presence of elements in this array. The idea is, for all multiples of each integer less than the maximum value of the array, try to make full binary tree if the multiple is present in the array.
Observe that for any full binary tree with given property, the smaller values will always be at the last level. So, try to find the number of such full binary tree from the minimum value of the array to maximum value of the array.

Algorithm to solve the problem:
1. Initialize possible number of such full binary tree for each element equal to 1. Since single node also contribute to the answer.
2. For each element of the array, arr[i], from minimum value to maximum value of array.
……a) For each multiple of arr[i], find if multiple is present or not.
……b) If yes, then the number of such possible full binary tree for multiple of arr[i], say m, is equal to the product of the number of such possible full binary tree of arr[i] and number of such possible full binary tree of arr[i]/m.

## C++

 `// C++ program to find number of full binary tree ` `// such that each node is product of its children. ` `#include ` `using` `namespace` `std; ` ` `  `// Return the number of all possible full binary ` `// tree with given product property. ` `int` `numoffbt(``int` `arr[], ``int` `n) ` `{ ` `    ``// Finding the minimum and maximum values in ` `    ``// given array. ` `    ``int` `maxvalue = INT_MIN, minvalue = INT_MAX; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``maxvalue = max(maxvalue, arr[i]); ` `        ``minvalue = min(minvalue, arr[i]); ` `    ``} ` ` `  `    ``int` `mark[maxvalue + 2]; ` `    ``int` `value[maxvalue + 2]; ` `    ``memset``(mark, 0, ``sizeof``(mark)); ` `    ``memset``(value, 0, ``sizeof``(value)); ` ` `  `    ``// Marking the presence of each array element ` `    ``// and initialising the number of possible ` `    ``// full binary tree for each integer equal ` `    ``// to 1 because single node will also ` `    ``// contribute as a full binary tree. ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``mark[arr[i]] = 1; ` `        ``value[arr[i]] = 1; ` `    ``} ` ` `  `    ``// From minimum value to maximum value of array ` `    ``// finding the number of all possible Full ` `    ``// Binary Trees. ` `    ``int` `ans = 0; ` `    ``for` `(``int` `i = minvalue; i <= maxvalue; i++) ` `    ``{ ` `        ``// Find if value present in the array ` `        ``if` `(mark[i]) ` `        ``{ ` `            ``// For each multiple of i, less than ` `            ``// equal to maximum value of array ` `            ``for` `(``int` `j = i + i; ` `                 ``j <= maxvalue && j/i <= i; j += i) ` `            ``{ ` `                ``// If multiple is not present in the ` `                ``// array then continue. ` `                ``if` `(!mark[j]) ` `                    ``continue``; ` ` `  `                ``// Finding the number of possible Full ` `                ``// binary trees for multiple j by ` `                ``// multiplying number of possible Full ` `                ``// binary tree from the number i and ` `                ``// number of possible Full binary tree ` `                ``// from i/j. ` `                ``value[j] = value[j] + (value[i] * value[j/i]); ` ` `  `                ``// Condition for possiblity when left ` `                ``// chid became right child and vice versa. ` `                ``if` `(i != j/i) ` `                    ``value[j] = value[j] + (value[i] * value[j/i]); ` `            ``} ` `        ``} ` ` `  `        ``ans += value[i]; ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Driven Program ` `int` `main() ` `{ ` `    ``int` `arr[] = { 2, 3, 4, 6 }; ` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr); ` ` `  `    ``cout << numoffbt(arr, n) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find number of full  ` `// binary tree such that each node is  ` `// product of its children. ` `import` `java.util.Arrays; ` ` `  `class` `GFG { ` `     `  `    ``// Return the number of all possible  ` `    ``// full binary tree with given product ` `    ``// property. ` `    ``static` `int` `numoffbt(``int` `arr[], ``int` `n) ` `    ``{ ` `         `  `        ``// Finding the minimum and maximum ` `        ``// values in given array. ` `        ``int` `maxvalue = -``2147483647``; ` `        ``int` `minvalue = ``2147483647``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``maxvalue = Math.max(maxvalue, arr[i]); ` `            ``minvalue = Math.min(minvalue, arr[i]); ` `        ``} ` `     `  `        ``int` `mark[] = ``new` `int``[maxvalue + ``2``]; ` `        ``int` `value[] = ``new` `int``[maxvalue + ``2``]; ` `        ``Arrays.fill(mark, ``0``); ` `        ``Arrays.fill(value, ``0``); ` `     `  `        ``// Marking the presence of each array element ` `        ``// and initialising the number of possible ` `        ``// full binary tree for each integer equal ` `        ``// to 1 because single node will also ` `        ``// contribute as a full binary tree. ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``mark[arr[i]] = ``1``; ` `            ``value[arr[i]] = ``1``; ` `        ``} ` `     `  `        ``// From minimum value to maximum value of array ` `        ``// finding the number of all possible Full ` `        ``// Binary Trees. ` `        ``int` `ans = ``0``; ` `        ``for` `(``int` `i = minvalue; i <= maxvalue; i++) ` `        ``{ ` `             `  `            ``// Find if value present in the array ` `            ``if` `(mark[i] != ``0``) ` `            ``{ ` `                ``// For each multiple of i, less than ` `                ``// equal to maximum value of array ` `                ``for` `(``int` `j = i + i; ` `                    ``j <= maxvalue && j/i <= i; j += i) ` `                ``{ ` `                    ``// If multiple is not present in ` `                    ``// the array then continue. ` `                    ``if` `(mark[j] == ``0``) ` `                        ``continue``; ` `     `  `                    ``// Finding the number of possible ` `                    ``// Full binary trees for multiple ` `                    ``// j by multiplying number of  ` `                    ``// possible Full binary tree from  ` `                    ``// the number i and number of  ` `                    ``// possible Full binary tree from i/j. ` `                    ``value[j] = value[j] + (value[i]  ` `                                          ``* value[j/i]); ` `     `  `                    ``// Condition for possiblity when  ` `                    ``// left chid became right child  ` `                    ``// and vice versa. ` `                    ``if` `(i != j / i) ` `                        ``value[j] = value[j] + (value[i] ` `                                         ``* value[j/i]); ` `                ``} ` `            ``} ` `     `  `            ``ans += value[i]; ` `        ``} ` `     `  `        ``return` `ans; ` `    ``} ` `     `  `    ``//driver code ` `    ``public` `static` `void` `main (String[] args) ` `    ``{ ` `        ``int` `arr[] = { ``2``, ``3``, ``4``, ``6` `}; ` `        ``int` `n = arr.length; ` `     `  `        ``System.out.print(numoffbt(arr, n)); ` `    ``} ` `} ` ` `  `//This code is contributed by Anant Agarwal. `

## Python3

 `  `  `# Python3 program to find number of ` `# full binary tree such that each node ` `# is product of its children. ` ` `  `# Return the number of all possible full  ` `# binary tree with given product property. ` `def` `numoffbt(arr, n): ` ` `  `    ``# Finding the minimum and maximum  ` `    ``# values in given array. ` `    ``maxvalue ``=` `-``2147483647` `    ``minvalue ``=` `2147483647` `    ``for` `i ``in` `range``(n): ` `     `  `        ``maxvalue ``=` `max``(maxvalue, arr[i]) ` `        ``minvalue ``=` `min``(minvalue, arr[i]) ` `     `  ` `  `    ``mark ``=` `[``0` `for` `i ``in` `range``(maxvalue ``+` `2``)] ` `    ``value ``=` `[``0` `for` `i ``in` `range``(maxvalue ``+` `2``)] ` ` `  `    ``# Marking the presence of each array element ` `    ``# and initialising the number of possible ` `    ``# full binary tree for each integer equal ` `    ``# to 1 because single node will also ` `    ``# contribute as a full binary tree. ` `    ``for` `i ``in` `range``(n): ` `     `  `        ``mark[arr[i]] ``=` `1` `        ``value[arr[i]] ``=` `1` `     `  ` `  `    ``# From minimum value to maximum value ` `    ``# of array finding the number of all  ` `    ``# possible Full Binary Trees. ` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(minvalue, maxvalue ``+` `1``): ` `     `  `        ``# Find if value present in the array ` `        ``if` `(mark[i] !``=` `0``): ` `         `  `            ``# For each multiple of i, less than ` `            ``# equal to maximum value of array ` `            ``j ``=` `i ``+` `i ` `            ``while``(j <``=` `maxvalue ``and` `j ``/``/` `i <``=` `i):  ` `             `  `                ``# If multiple is not present in the ` `                ``# array then continue. ` `                ``if` `(mark[j] ``=``=` `0``): ` `                    ``continue` ` `  `                ``# Finding the number of possible Full ` `                ``# binary trees for multiple j by ` `                ``# multiplying number of possible Full ` `                ``# binary tree from the number i and ` `                ``# number of possible Full binary tree ` `                ``# from i/j. ` `                ``value[j] ``=` `value[j] ``+` `(value[i] ``*` `value[j ``/``/` `i]) ` ` `  `                ``# Condition for possiblity when left ` `                ``# chid became right child and vice versa. ` `                ``if` `(i !``=` `j ``/``/` `i): ` `                    ``value[j] ``=` `value[j] ``+` `(value[i] ``*` `value[j ``/``/` `i]) ` `                ``j ``+``=` `i          ` `             `  ` `  `        ``ans ``+``=` `value[i] ` `     `  `    ``return` `ans ` ` `  `# Driver Code ` `arr ``=` `[ ``2``, ``3``, ``4``, ``6` `] ` `n ``=` `len``(arr) ` ` `  `print``(numoffbt(arr, n)) ` ` `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# program to find number of  ` `// full binary tree such that each ` `// node is product of its children. ` `using` `System; ` ` `  `class` `GFG ` `{ ` `    ``// Return the number of all possible full binary ` `    ``// tree with given product property. ` `    ``static` `int` `numoffbt(``int` `[]arr, ``int` `n) ` `    ``{ ` `        ``// Finding the minimum and maximum values in ` `        ``// given array. ` `        ``int` `maxvalue = -2147483647, minvalue = 2147483647; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``maxvalue = Math.Max(maxvalue, arr[i]); ` `            ``minvalue = Math.Min(minvalue, arr[i]); ` `        ``} ` `      `  `        ``int` `[]mark=``new` `int``[maxvalue + 2]; ` `        ``int` `[]value=``new` `int``[maxvalue + 2]; ` `        ``for``(``int` `i = 0;i < maxvalue + 2; i++) ` `            ``{ ` `                ``mark[i]=0; ` `                ``value[i]=0; ` `            ``} ` `      `  `        ``// Marking the presence of each array element ` `        ``// and initialising the number of possible ` `        ``// full binary tree for each integer equal ` `        ``// to 1 because single node will also ` `        ``// contribute as a full binary tree. ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``mark[arr[i]] = 1; ` `            ``value[arr[i]] = 1; ` `        ``} ` `      `  `        ``// From minimum value to maximum value of array ` `        ``// finding the number of all possible Full ` `        ``// Binary Trees. ` `        ``int` `ans = 0; ` `        ``for` `(``int` `i = minvalue; i <= maxvalue; i++) ` `        ``{ ` `            ``// Find if value present in the array ` `            ``if` `(mark[i] != 0) ` `            ``{ ` `                ``// For each multiple of i, less than ` `                ``// equal to maximum value of array ` `                ``for` `(``int` `j = i + i; ` `                     ``j <= maxvalue && j/i <= i; j += i) ` `                ``{ ` `                    ``// If multiple is not present in the ` `                    ``// array then continue. ` `                    ``if` `(mark[j] == 0) ` `                        ``continue``; ` `      `  `                    ``// Finding the number of possible Full ` `                    ``// binary trees for multiple j by ` `                    ``// multiplying number of possible Full ` `                    ``// binary tree from the number i and ` `                    ``// number of possible Full binary tree ` `                    ``// from i/j. ` `                    ``value[j] = value[j] + (value[i] * value[j/i]); ` `      `  `                    ``// Condition for possiblity when left ` `                    ``// chid became right child and vice versa. ` `                    ``if` `(i != j/i) ` `                        ``value[j] = value[j] + (value[i] * value[j/i]); ` `                ``} ` `            ``} ` `      `  `            ``ans += value[i]; ` `        ``} ` `      `  `        ``return` `ans; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = { 2, 3, 4, 6 }; ` `        ``int` `n = arr.Length; ` `      `  `        ``Console.Write(numoffbt(arr, n)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

Output:

```7
```

This article is contributed by Anuj Chauhan(anuj0503). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

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.

My Personal Notes arrow_drop_up

Improved By : Akanksha_Rai

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.