Skip to content

Beat the competition and land yourself a top job. Register for Job-a-thon now!

Related Articles

Related Articles

Count of Nodes whose both immediate children are its prime factors

View Discussion
Improve Article
Save Article
Like Article
  • Difficulty Level : Medium
  • Last Updated : 23 Jun, 2021

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

 

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 <bits/stdc++.h>
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<Node*> 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<Integer> prime = new Vector<Integer>();
  
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<Node> 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<Node> q = new List<Node>();
   
    // 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[0];
        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
Javascript



<script>
 
    // JavaScript program for Counting nodes
    // whose immediate children are its factors
     
    let N = 1000000;
    
    // To store all prime numbers
    let prime = [];
 
    function 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.
        let check = new Array(N + 1);
        check.fill(true);
 
        for (let p = 2; p * p <= N; p++) {
 
            // If prime[p] is not changed,
            // then it is a prime
            if (check[p] == true) {
 
                prime.push(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 (let i = p * p; i <= N; i += p)
                    check[i] = false;
            }
        }
    }
 
    // A Tree node
    class Node {
        constructor(key)
        {
            this.key = key;
            this.left = null;
            this.right = null;
        }
    }
 
    // Utility function to create a new node
    function newNode(key)
    {
        let temp = new Node(key);
        return (temp);
    }
 
    // function to check and print if
    // immediate children of a node
    // are its factors or not
    function areChilrenPrimeFactors(parent, a, b)
    {
        if (prime[a.key] != null && prime[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
    function getCount(node)
    {
        // If tree is empty
        if (node == null)
            return 0;
        let q = [];
 
        // Initialize count of ful/l nodes
        // having children as their factors
        let count = 0;
 
        // Do level order traversal
        // starting from root
        q.push(node);
        while (q.length > 0) {
            let temp = q[0];
            q.shift();
 
            if (temp.left!=null && temp.right != null) {
                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
    function findSize(node)
    {
        // Base condition
        if (node == null)
            return 0;
 
        return 1
               + findSize(node.left)
               + findSize(node.right);
    }
     
    /*       10
            /   \
           2     5
               /   \
              18    12
              / \   / \
             2   3 3   2
                      /
                     7
    */
    
    // Create Binary Tree as shown
    let 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
    document.write(getCount(root) +"</br>");
 
</script>
Output: 
3
 

My Personal Notes
arrow_drop_up
Next

Count of nodes in a Binary tree with immediate children as its factors
Recommended Articles
Page :
Count of nodes in a Binary tree with immediate children as its factors
09, Apr 20
Count of nodes in a Binary Tree whose immediate children are co-prime
09, Apr 20
Print all numbers whose set of prime factors is a subset of the set of the prime factors of X
22, Apr 19
Count of nodes in a Binary Tree whose child is its prime factors
09, Apr 20
Count numbers in a given range whose count of prime factors is a Prime Number
28, Oct 20
Node having maximum sum of immediate children and itself in n-ary tree
11, Oct 17
Count of Nodes whose children gives same remainder when divided by K
26, Jan 22
Minimize changes to convert into Tree with root 1, even left children and odd right children
29, Mar 22
Second unique smallest value of given Binary Tree whose each node is minimum of its children
04, Apr 22
Find nodes whose children have same modulo with K
26, Jan 22
Check if a number exists having exactly N factors and K prime factors
10, May 20
Maximum number of prime factors a number can have with exactly x factors
07, May 20
Count numbers from range whose prime factors are only 2 and 3
04, Dec 18
Find the row whose product has maximum count of prime factors
22, Apr 20
Count numbers from range whose prime factors are only 2 and 3 using Arrays | Set 2
31, May 20
Check whether every node of binary tree has a value K on itself or its any immediate neighbours
15, Jul 20
Given a n-ary tree, count number of nodes which have more number of children than parents
02, Oct 17
Count nodes with two children at level L in a Binary Tree
22, Mar 19
Find prime factors of Array elements whose sum of exponents is divisible by K
15, Aug 20
Super Ugly Number (Number whose prime factors are in given set)
05, Jan 17
Sum of element whose prime factors are present in array
21, Dec 18
Product of divisors of a number from a given list of its prime factors
15, Jul 20
Find prime factors of Z such that Z is product of all even numbers till N that are product of two distinct prime numbers
28, Jun 21
Count pairs from an array with even product of count of distinct prime factors
22, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Code_r
@Code_r
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!