Count of nodes in a Binary Tree whose child is its prime factors
Given a Binary Tree, the task is to print the count of nodes whose either of the immediate child is its prime factors.
Examples:
Input:
1
/ \
15 20
/ \ / \
3 5 4 2
\ /
2 3
Output: 3
Explanation:
Children of 15 (3, 5)
are prime factors of 15
Child of 20 (2)
is prime factors of 20
Child of 4 (2)
is prime factors of 4
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 30Approach:
- Traverse the given Binary Tree and for each node:
- Check if children exist or not.
- If the children exist, check if each child is a prime factor of this node or not.
- Keep the count of such nodes and print it at the end.
- In order to check if a factor is prime, we will use Sieve of Eratosthenes 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 numbersvector<int> prime;void SieveOfEratosthenes(){ // Create a boolean array "prime[0..N]" and initialize // all its entries 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 nodetypedef struct Node { int key; struct Node *left, *right;} Node;// Utility function to create a new nodeNode* newNode(int key){ Node* temp = new Node; temp->key = key; temp->left = temp->right = NULL; return (temp);}// Function to check if immediate children// of a node are its factors or notbool IsChilrenPrimeFactor(Node* parent, Node* a){ if (prime[a->key] && (parent->key % a->key == 0)) return true; else return false;}// Function to get the count of full Nodes in a binary treeunsigned int GetCount(struct Node* node){ // If tree is empty if (!node) return 0; queue<Node*> q; // Do level order traversal starting from root // Initialize count of full nodes having children as their factors int count = 0; q.push(node); while (!q.empty()) { struct Node* temp = q.front(); q.pop(); // If only right child exist if (temp->left == NULL && temp->right != NULL) { if (IsChilrenPrimeFactor(temp, temp->right)) count++; } else { // If only left child exist if (temp->right == NULL && temp->left != NULL) { if (IsChilrenPrimeFactor(temp, temp->left)) count++; } else { // Both left and right child exist if (temp->left != NULL && temp->right != NULL) { if (IsChilrenPrimeFactor(temp, temp->right) && IsChilrenPrimeFactor(temp, temp->left)) count++; } } } // Check for left child if (temp->left != NULL) q.push(temp->left); // Check for right child if (temp->right != NULL) q.push(temp->right); } return count;}// Driver Codeint main(){ /* 10 / \ 2 5 / \ 18 12 / \ / \ 2 3 3 14 / 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(14); root->right->right->right->left = newNode(7); // To save all prime numbers SieveOfEratosthenes(); // Print Count of all nodes having children // as their factors cout << GetCount(root) << endl; return 0;} |
Java
// Java program for Counting nodes whose// immediate children are its factorsimport java.util.*;class GFG{ static int N = 1000000; // To store all prime numbersstatic Vector<Integer> prime = new Vector<Integer>(); static void SieveOfEratosthenes(){ // Create a boolean array "prime[0..N]" // and initialize all its entries 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 nodestatic class Node { int key; Node left, right;}; // Utility function to create a new nodestatic Node newNode(int key){ Node temp = new Node(); temp.key = key; temp.left = temp.right = null; return (temp);} // Function to check if immediate children// of a node are its factors or notstatic boolean IsChilrenPrimeFactor(Node parent, Node a){ if (prime.get(a.key)>0 && (parent.key % a.key == 0)) return true; else return false;} // Function to get the count of full Nodes in// a binary treestatic int GetCount(Node node){ // If tree is empty if (node == null) return 0; Queue<Node> q = new LinkedList<>(); // Do level order traversal starting // from root // Initialize count of full nodes having // children as their factors int count = 0; q.add(node); while (!q.isEmpty()) { Node temp = q.peek(); q.remove(); // If only right child exist if (temp.left == null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right)) count++; } else { // If only left child exist if (temp.right == null && temp.left != null) { if (IsChilrenPrimeFactor( temp, temp.left)) count++; } else { // Both left and right child exist if (temp.left != null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right) && IsChilrenPrimeFactor( temp, temp.left)) count++; } } } // Check for left child if (temp.left != null) q.add(temp.left); // Check for right child if (temp.right != null) q.add(temp.right); } return count;} // Driver Codepublic static void main(String[] args){ /* 10 / \ 2 5 / \ 18 12 / \ / \ 2 3 3 14 / 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(14); root.right.right.right.left = newNode(7); // To save all prime numbers SieveOfEratosthenes(); // Print Count of all nodes having children // as their factors System.out.print(GetCount(root) +"\n"); }}// This code is contributed by Rajput-Ji |
Python3
# Python program for Counting nodes whose# immediate children are its factorsfrom collections import dequeN = 1000000# To store all prime numbersprime = []def SieveOfEratosthenes() -> None: # Create a boolean array "prime[0..N]" # and initialize all its entries as true. # A value in prime[i] will finally # be false if i is Not a prime, else true. check = [True for _ in range(N + 1)] p = 2 while p * p <= N: # If prime[p] is not changed, # then it is a prime if (check[p]): prime.append(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 i in range(p * p, N + 1, p): check[i] = False p += 1# A Tree nodeclass Node: def __init__(self, key: int) -> None: self.key = key self.left = None self.right = None# Function to check if immediate children# of a node are its factors or notdef IsChilrenPrimeFactor(parent: Node, a: Node) -> bool: if (prime[a.key] and (parent.key % a.key == 0)): return True else: return False# Function to get the count of full Nodes in# a binary treedef GetCount(node: Node) -> int: # If tree is empty if (not node): return 0 q = deque() # Do level order traversal starting # from root # Initialize count of full nodes having # children as their factors count = 0 q.append(node) while q: temp = q.popleft() # If only right child exist if (temp.left == None and temp.right != None): if (IsChilrenPrimeFactor(temp, temp.right)): count += 1 else: # If only left child exist if (temp.right == None and temp.left != None): if (IsChilrenPrimeFactor(temp, temp.left)): count += 1 else: # Both left and right child exist if (temp.left != None and temp.right != None): if (IsChilrenPrimeFactor(temp, temp.right) and IsChilrenPrimeFactor(temp, temp.left)): count += 1 # Check for left child if (temp.left != None): q.append(temp.left) # Check for right child if (temp.right != None): q.append(temp.right) return count# Driver Codeif __name__ == "__main__": ''' 10 / \ 2 5 / \ 18 12 / \ / \ 2 3 3 14 / 7 ''' # Create Binary Tree as shown root = Node(10) root.left = Node(2) root.right = Node(5) root.right.left = Node(18) root.right.right = Node(12) root.right.left.left = Node(2) root.right.left.right = Node(3) root.right.right.left = Node(3) root.right.right.right = Node(14) root.right.right.right.left = Node(7) # To save all prime numbers SieveOfEratosthenes() # Print Count of all nodes having children # as their factors print(GetCount(root))# This code is contributed by sanjeev2552 |
C#
// C# program for Counting nodes whose// immediate children are its factorsusing System;using System.Collections.Generic;public class GFG{ static int N = 1000000; // To store all prime numbersstatic List<int> prime = new List<int>(); static void SieveOfEratosthenes(){ // Create a bool array "prime[0..N]" // and initialize all its entries 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 nodeclass Node { public int key; public Node left, right;}; // Utility function to create a new nodestatic Node newNode(int key){ Node temp = new Node(); temp.key = key; temp.left = temp.right = null; return (temp);} // Function to check if immediate children// of a node are its factors or notstatic bool IsChilrenPrimeFactor(Node parent, Node a){ if (prime[a.key]>0 && (parent.key % a.key == 0)) return true; else return false;} // Function to get the count of full Nodes in// a binary treestatic int GetCount(Node node){ // If tree is empty if (node == null) return 0; List<Node> q = new List<Node>(); // Do level order traversal starting // from root // Initialize count of full nodes having // children as their factors int count = 0; q.Add(node); while (q.Count!=0) { Node temp = q[0]; q.RemoveAt(0); // If only right child exist if (temp.left == null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right)) count++; } else { // If only left child exist if (temp.right == null && temp.left != null) { if (IsChilrenPrimeFactor( temp, temp.left)) count++; } else { // Both left and right child exist if (temp.left != null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right) && IsChilrenPrimeFactor( temp, temp.left)) count++; } } } // Check for left child if (temp.left != null) q.Add(temp.left); // Check for right child if (temp.right != null) q.Add(temp.right); } return count;} // Driver Codepublic static void Main(String[] args){ /* 10 / \ 2 5 / \ 18 12 / \ / \ 2 3 3 14 / 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(14); root.right.right.right.left = newNode(7); // To save all prime numbers SieveOfEratosthenes(); // Print Count of all nodes having children // as their factors Console.Write(GetCount(root) +"\n"); }}// This code 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 its entries 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.left = null; this.right = null; this.key = key; } } // Utility function to create a new node function newNode(key) { let temp = new Node(key); return (temp); } // Function to check if immediate children // of a node are its factors or not function IsChilrenPrimeFactor(parent, a) { if (prime[a.key]>0 && (parent.key % a.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 = []; // Do level order traversal starting // from root // Initialize count of full nodes having // children as their factors let count = 0; q.push(node); while (q.length > 0) { let temp = q[0]; q.shift(); // If only right child exist if (temp.left == null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right)) count++; } else { // If only left child exist if (temp.right == null && temp.left != null) { if (IsChilrenPrimeFactor( temp, temp.left)) count++; } else { // Both left and right child exist if (temp.left != null && temp.right != null) { if (IsChilrenPrimeFactor( temp, temp.right) && IsChilrenPrimeFactor( temp, temp.left)) count++; } } } // Check for left child if (temp.left != null) q.push(temp.left); // Check for right child if (temp.right != null) q.push(temp.right); } return count; } /* 10 / \ 2 5 / \ 18 12 / \ / \ 2 3 3 14 / 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(14); root.right.right.right.left = newNode(7); // To save all prime numbers SieveOfEratosthenes(); // Print Count of all nodes having children // as their factors document.write(GetCount(root) +"</br>"); </script> |
Output:
3
Complexity Analysis:
- Time Complexity: O(N).
In dfs, every node of the tree is processed once and hence the complexity due to the bfs is O(N) if there are total N nodes in the tree. Also, for processing each node the SieveOfEratosthenes() function is used which has a complexity of O(sqrt(N)) too but since this function is executed only once, it does not affect the overall time complexity. Therefore, the time complexity is O(N).- Auxiliary Space: O(N).
Extra space is used for the prime array, so the space complexity is O(N).
.png)
