# Count of Nodes whose both immediate children are its prime factors

Given a Binary Tree, the task is to print the count of nodes having both children and both of them are its prime factors.

Examples:

```Input:
1
/   \
15     20
/  \   /  \
3    5 4     2
\    /
2  3
Output: 1
Explanation:
Children of 15 (3, 5) are prime factors of 15

Input:
7
/  \
210   14
/  \      \
70   14     30
/ \         / \
2   5       3   5
/
23
Output: 2
Explanation:
Children of 70 (2, 5) are prime factors of 70
Children of 30 (3, 5) are prime factors of 30
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach:

1. Traverse the given Binary Tree and for each node, check both the children exists or not.
2. If both the children exist, check if each child is a prime factor of this node or not.
3. Keep the count of such nodes and print it at the end.
4. In order to check if a factor is prime, we will use Sieve to precompute the prime numbers to do the checking in O(1).

Below is the implementation of the above approach.

## C++

 `// C++ program for Counting nodes ` `// whose immediate children are its factors ` ` `  `#include ` `using` `namespace` `std; ` ` `  `int` `N = 1000000; ` ` `  `// To store all prime numbers ` `vector<``int``> prime; ` ` `  `void` `SieveOfEratosthenes() ` `{ ` `    ``// Create a boolean array "prime[0..N]" ` `    ``// and initialize all entries it as true. ` `    ``// A value in prime[i] will finally ` `    ``// be false if i is Not a prime, else true. ` `    ``bool` `check[N + 1]; ` `    ``memset``(check, ``true``, ``sizeof``(check)); ` ` `  `    ``for` `(``int` `p = 2; p * p <= N; p++) { ` ` `  `        ``// If prime[p] is not changed, ` `        ``// then it is a prime ` `        ``if` `(check[p] == ``true``) { ` ` `  `            ``prime.push_back(p); ` ` `  `            ``// Update all multiples of p ` `            ``// greater than or equal to ` `            ``// the square of it ` `            ``// numbers which are multiples of p ` `            ``// and are less than p^2 ` `            ``// are already marked. ` `            ``for` `(``int` `i = p * p; i <= N; i += p) ` `                ``check[i] = ``false``; ` `        ``} ` `    ``} ` `} ` ` `  `// A Tree node ` `struct` `Node { ` `    ``int` `key; ` `    ``struct` `Node *left, *right; ` `}; ` ` `  `// Utility function to create a new node ` `Node* newNode(``int` `key) ` `{ ` `    ``Node* temp = ``new` `Node; ` `    ``temp->key = key; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `(temp); ` `} ` ` `  `// function to check and print if ` `// immediate children of a node ` `// are its factors or not ` `bool` `areChilrenPrimeFactors(``struct` `Node* parent, ` `                            ``struct` `Node* a, ` `                            ``struct` `Node* b) ` `{ ` `    ``if` `(prime[a->key] && prime[b->key] ` `        ``&& (parent->key % a->key == 0 ` `            ``&& parent->key % b->key == 0)) ` `        ``return` `true``; ` `    ``else` `        ``return` `false``; ` `} ` ` `  `// Function to get the count of full Nodes in ` `// a binary tree ` `unsigned ``int` `getCount(``struct` `Node* node) ` `{ ` `    ``// If tree is empty ` `    ``if` `(!node) ` `        ``return` `0; ` `    ``queue q; ` ` `  `    ``// Initialize count of ful/l nodes ` `    ``// having children as their factors ` `    ``int` `count = 0; ` ` `  `    ``// Do level order traversal ` `    ``// starting from root ` `    ``q.push(node); ` `    ``while` `(!q.empty()) { ` `        ``struct` `Node* temp = q.front(); ` `        ``q.pop(); ` ` `  `        ``if` `(temp->left && temp->right) { ` `            ``if` `(areChilrenPrimeFactors( ` `                    ``temp, temp->left, ` `                    ``temp->right)) ` `                ``count++; ` `        ``} ` ` `  `        ``if` `(temp->left != NULL) ` `            ``q.push(temp->left); ` `        ``if` `(temp->right != NULL) ` `            ``q.push(temp->right); ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Function to find total no of nodes ` `// In a given binary tree ` `int` `findSize(``struct` `Node* node) ` `{ ` `    ``// Base condition ` `    ``if` `(node == NULL) ` `        ``return` `0; ` ` `  `    ``return` `1 ` `           ``+ findSize(node->left) ` `           ``+ findSize(node->right); ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``/*       10  ` `            ``/   \  ` `           ``2     5  ` `               ``/   \  ` `              ``18    12  ` `              ``/ \   / \  ` `             ``2   3 3   2  ` `                      ``/  ` `                     ``7 ` `    ``*/` ` `  `    ``// Create Binary Tree as shown ` `    ``Node* root = newNode(10); ` ` `  `    ``root->left = newNode(2); ` `    ``root->right = newNode(5); ` ` `  `    ``root->right->left = newNode(18); ` `    ``root->right->right = newNode(12); ` ` `  `    ``root->right->left->left = newNode(2); ` `    ``root->right->left->right = newNode(3); ` `    ``root->right->right->left = newNode(3); ` `    ``root->right->right->right = newNode(2); ` `    ``root->right->right->right->left = newNode(7); ` ` `  `    ``// To save all prime numbers ` `    ``SieveOfEratosthenes(); ` ` `  `    ``// Print all nodes having ` `    ``// children as their factors ` `    ``cout << getCount(root) << endl; ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for Counting nodes ` `// whose immediate children are its factors ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `  `  `static` `int` `N = ``1000000``; ` `  `  `// To store all prime numbers ` `static` `Vector prime = ``new` `Vector(); ` `  `  `static` `void` `SieveOfEratosthenes() ` `{ ` `    ``// Create a boolean array "prime[0..N]" ` `    ``// and initialize all entries it as true. ` `    ``// A value in prime[i] will finally ` `    ``// be false if i is Not a prime, else true. ` `    ``boolean` `[]check = ``new` `boolean``[N + ``1``]; ` `    ``Arrays.fill(check, ``true``); ` `  `  `    ``for` `(``int` `p = ``2``; p * p <= N; p++) { ` `  `  `        ``// If prime[p] is not changed, ` `        ``// then it is a prime ` `        ``if` `(check[p] == ``true``) { ` `  `  `            ``prime.add(p); ` `  `  `            ``// Update all multiples of p ` `            ``// greater than or equal to ` `            ``// the square of it ` `            ``// numbers which are multiples of p ` `            ``// and are less than p^2 ` `            ``// are already marked. ` `            ``for` `(``int` `i = p * p; i <= N; i += p) ` `                ``check[i] = ``false``; ` `        ``} ` `    ``} ` `} ` `  `  `// A Tree node ` `static` `class` `Node { ` `    ``int` `key; ` `    ``Node left, right; ` `}; ` `  `  `// Utility function to create a new node ` `static` `Node newNode(``int` `key) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.key = key; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `(temp); ` `} ` `  `  `// function to check and print if ` `// immediate children of a node ` `// are its factors or not ` `static` `boolean` `areChilrenPrimeFactors(Node parent, ` `                            ``Node a, ` `                            ``Node b) ` `{ ` `    ``if` `(prime.get(a.key) != ``null` `&& prime.get(b.key) != ``null` `        ``&& (parent.key % a.key == ``0` `            ``&& parent.key % b.key == ``0``)) ` `        ``return` `true``; ` `    ``else` `        ``return` `false``; ` `} ` `  `  `// Function to get the count of full Nodes in ` `// a binary tree ` `static` `int` `getCount(Node node) ` `{ ` `    ``// If tree is empty ` `    ``if` `(node == ``null``) ` `        ``return` `0``; ` `    ``Queue q = ``new` `LinkedList<>(); ` `  `  `    ``// Initialize count of ful/l nodes ` `    ``// having children as their factors ` `    ``int` `count = ``0``; ` `  `  `    ``// Do level order traversal ` `    ``// starting from root ` `    ``q.add(node); ` `    ``while` `(!q.isEmpty()) { ` `        ``Node temp = q.peek(); ` `        ``q.remove(); ` `  `  `        ``if` `(temp.left!=``null` `&& temp.right != ``null``) { ` `            ``if` `(areChilrenPrimeFactors( ` `                    ``temp, temp.left, ` `                    ``temp.right)) ` `                ``count++; ` `        ``} ` `  `  `        ``if` `(temp.left != ``null``) ` `            ``q.add(temp.left); ` `        ``if` `(temp.right != ``null``) ` `            ``q.add(temp.right); ` `    ``} ` `    ``return` `count; ` `} ` `  `  `// Function to find total no of nodes ` `// In a given binary tree ` `static` `int` `findSize(Node node) ` `{ ` `    ``// Base condition ` `    ``if` `(node == ``null``) ` `        ``return` `0``; ` `  `  `    ``return` `1` `           ``+ findSize(node.left) ` `           ``+ findSize(node.right); ` `} ` `  `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``/*       10  ` `            ``/   \  ` `           ``2     5  ` `               ``/   \  ` `              ``18    12  ` `              ``/ \   / \  ` `             ``2   3 3   2  ` `                      ``/  ` `                     ``7 ` `    ``*/` `  `  `    ``// Create Binary Tree as shown ` `    ``Node root = newNode(``10``); ` `  `  `    ``root.left = newNode(``2``); ` `    ``root.right = newNode(``5``); ` `  `  `    ``root.right.left = newNode(``18``); ` `    ``root.right.right = newNode(``12``); ` `  `  `    ``root.right.left.left = newNode(``2``); ` `    ``root.right.left.right = newNode(``3``); ` `    ``root.right.right.left = newNode(``3``); ` `    ``root.right.right.right = newNode(``2``); ` `    ``root.right.right.right.left = newNode(``7``); ` `  `  `    ``// To save all prime numbers ` `    ``SieveOfEratosthenes(); ` `  `  `    ``// Print all nodes having ` `    ``// children as their factors ` `    ``System.out.print(getCount(root) +``"\n"``); ` `  `  `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## C#

 `// C# program for Counting nodes ` `// whose immediate children are its factors ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` `   `  `static` `int` `N = 1000000; ` `   `  `// To store all prime numbers ` `static` `List<``int``> prime = ``new` `List<``int``>(); ` `   `  `static` `void` `SieveOfEratosthenes() ` `{ ` `    ``// Create a bool array "prime[0..N]" ` `    ``// and initialize all entries it as true. ` `    ``// A value in prime[i] will finally ` `    ``// be false if i is Not a prime, else true. ` `    ``bool` `[]check = ``new` `bool``[N + 1]; ` `    ``for` `(``int` `i = 0; i <= N; i += 1){ ` `        ``check[i] = ``true``; ` `    ``} ` `   `  `    ``for` `(``int` `p = 2; p * p <= N; p++) { ` `   `  `        ``// If prime[p] is not changed, ` `        ``// then it is a prime ` `        ``if` `(check[p] == ``true``) { ` `   `  `            ``prime.Add(p); ` `   `  `            ``// Update all multiples of p ` `            ``// greater than or equal to ` `            ``// the square of it ` `            ``// numbers which are multiples of p ` `            ``// and are less than p^2 ` `            ``// are already marked. ` `            ``for` `(``int` `i = p * p; i <= N; i += p) ` `                ``check[i] = ``false``; ` `        ``} ` `    ``} ` `} ` `   `  `// A Tree node ` `class` `Node { ` `    ``public` `int` `key; ` `    ``public` `Node left, right; ` `}; ` `   `  `// Utility function to create a new node ` `static` `Node newNode(``int` `key) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.key = key; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `(temp); ` `} ` `   `  `// function to check and print if ` `// immediate children of a node ` `// are its factors or not ` `static` `bool` `areChilrenPrimeFactors(Node parent, ` `                            ``Node a, ` `                            ``Node b) ` `{ ` `    ``if` `(prime.Contains(a.key)&& prime.Contains(b.key) ` `        ``&& (parent.key % a.key == 0 ` `            ``&& parent.key % b.key == 0)) ` `        ``return` `true``; ` `    ``else` `        ``return` `false``; ` `} ` `   `  `// Function to get the count of full Nodes in ` `// a binary tree ` `static` `int` `getCount(Node node) ` `{ ` `    ``// If tree is empty ` `    ``if` `(node == ``null``) ` `        ``return` `0; ` `    ``List q = ``new` `List(); ` `   `  `    ``// Initialize count of ful/l nodes ` `    ``// having children as their factors ` `    ``int` `count = 0; ` `   `  `    ``// Do level order traversal ` `    ``// starting from root ` `    ``q.Add(node); ` `    ``while` `(q.Count!=0) { ` `        ``Node temp = q; ` `        ``q.RemoveAt(0); ` `   `  `        ``if` `(temp.left!=``null` `&& temp.right != ``null``) { ` `            ``if` `(areChilrenPrimeFactors( ` `                    ``temp, temp.left, ` `                    ``temp.right)) ` `                ``count++; ` `        ``} ` `   `  `        ``if` `(temp.left != ``null``) ` `            ``q.Add(temp.left); ` `        ``if` `(temp.right != ``null``) ` `            ``q.Add(temp.right); ` `    ``} ` `    ``return` `count; ` `} ` `   `  `// Function to find total no of nodes ` `// In a given binary tree ` `static` `int` `findSize(Node node) ` `{ ` `    ``// Base condition ` `    ``if` `(node == ``null``) ` `        ``return` `0; ` `   `  `    ``return` `1 ` `           ``+ findSize(node.left) ` `           ``+ findSize(node.right); ` `} ` `   `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``/*       10  ` `            ``/   \  ` `           ``2     5  ` `               ``/   \  ` `              ``18    12  ` `              ``/ \   / \  ` `             ``2   3 3   2  ` `                      ``/  ` `                     ``7 ` `    ``*/` `   `  `    ``// Create Binary Tree as shown ` `    ``Node root = newNode(10); ` `   `  `    ``root.left = newNode(2); ` `    ``root.right = newNode(5); ` `   `  `    ``root.right.left = newNode(18); ` `    ``root.right.right = newNode(12); ` `   `  `    ``root.right.left.left = newNode(2); ` `    ``root.right.left.right = newNode(3); ` `    ``root.right.right.left = newNode(3); ` `    ``root.right.right.right = newNode(2); ` `    ``root.right.right.right.left = newNode(7); ` `   `  `    ``// To save all prime numbers ` `    ``SieveOfEratosthenes(); ` `   `  `    ``// Print all nodes having ` `    ``// children as their factors ` `    ``Console.Write(getCount(root) +``"\n"``); ` `   `  `} ` `} ` `  `  `// This code is contributed by Rajput-Ji `

Output:

```3
```

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 Check out this Author's contributed articles.

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.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Rajput-Ji

Article Tags :
Practice Tags :

1

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