Related Articles
Count of Nodes whose both immediate children are its prime factors
• Difficulty Level : Medium
• Last Updated : 27 Apr, 2020

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
```

My Personal Notes arrow_drop_up