Given a tree, and the weights of all the nodes, the task is to count the number of nodes whose weight is a Powerful Number.
A number n is said to be Powerful Number if, for every prime factor p of it, p2 also divides it.
Example:
Input:
Output: 3
Explanation:
4, 16 and 25 are powerful weights in the tree.
Approach: To solve the problem mentioned above, we have to perform Depth First Search(DFS) on the tree and for every node, check if it’s weight is a powerful number or not. If yes then increment the count.
Below is the implementation of the above approach:
C++
// C++ implementation to Count the nodes in the// given tree whose weight is a powerful number#include <bits/stdc++.h>using namespace std;int ans = 0;vector<int> graph[100];vector<int> weight(100);// Function to check if the number is powerfulbool isPowerful(int n){ // First divide the number repeatedly by 2 while (n % 2 == 0) { int power = 0; while (n % 2 == 0) { n /= 2; power++; } // Check if only 2^1 divides n, // then return false if (power == 1) return false; } // Check if n is not a power of 2 // then this loop will execute for (int factor = 3; factor <= sqrt(n); factor += 2) { // Find highest power of "factor" // that divides n int power = 0; while (n % factor == 0) { n = n / factor; power++; } // Check if only factor^1 divides n, // then return false if (power == 1) return false; } // n must be 1 now // if it is not a prime number. // Since prime numbers are not powerful, // we return false if n is not 1. return (n == 1);}// Function to perform dfsvoid dfs(int node, int parent){ // Check if weight of the current node // is a powerful number if (isPowerful(weight[node])) ans += 1; for (int to : graph[node]) { if (to == parent) continue; dfs(to, node); }}// Driver codeint main(){ // Weights of the node weight[1] = 5; weight[2] = 10; weight[3] = 11; weight[4] = 8; weight[5] = 6; // Edges of the tree graph[1].push_back(2); graph[2].push_back(3); graph[2].push_back(4); graph[1].push_back(5); dfs(1, 1); cout << ans; return 0;} |
Java
//Java implementation to Count the nodes in the//given tree whose weight is a powerful numberimport java.util.*;class GFG {static int ans = 0;static Vector<Integer>[] graph = new Vector[100];static int[] weight = new int[100];// Function to check if the number is powerfulstatic boolean isPowerful(int n) { // First divide the number repeatedly by 2 while (n % 2 == 0) { int power = 0; while (n % 2 == 0) { n /= 2; power++; } // Check if only 2^1 divides n, // then return false if (power == 1) return false; } // Check if n is not a power of 2 // then this loop will execute for (int factor = 3; factor <= Math.sqrt(n); factor += 2) { // Find highest power of "factor" // that divides n int power = 0; while (n % factor == 0) { n = n / factor; power++; } // Check if only factor^1 divides n, // then return false if (power == 1) return false; } // n must be 1 now // if it is not a prime number. // Since prime numbers are not powerful, // we return false if n is not 1. return (n == 1);}// Function to perform dfsstatic void dfs(int node, int parent) { // Check if weight of the current node // is a powerful number if (isPowerful(weight[node])) ans += 1; for (int to : graph[node]) { if (to == parent) continue; dfs(to, node); }}// Driver codepublic static void main(String[] args) { for (int i = 0; i < graph.length; i++) graph[i] = new Vector<Integer>(); // Weights of the node weight[1] = 5; weight[2] = 10; weight[3] = 11; weight[4] = 8; weight[5] = 6; // Edges of the tree graph[1].add(2); graph[2].add(3); graph[2].add(4); graph[1].add(5); dfs(1, 1); System.out.print(ans);}}// This code is contributed by Princi Singh |
Python3
# Python3 implementation to# Count the Nodes in the given# tree whose weight is a powerful # numbergraph = [[] for i in range(100)]weight = [0] * 100ans = 0# Function to check if the # number is powerfuldef isPowerful(n): # First divide the number # repeatedly by 2 while (n % 2 == 0): power = 0; while (n % 2 == 0): n /= 2; power += 1; # Check if only 2^1 # divides n, then # return False if (power == 1): return False; # Check if n is not a # power of 2 then this # loop will execute factor = 3 while(factor *factor <=n): # Find highest power of # "factor" that divides n power = 0; while (n % factor == 0): n = n / factor; power += 1; # Check if only factor^1 # divides n, then return # False if (power == 1): return False; factor +=2; # n must be 1 now # if it is not a prime # number. Since prime # numbers are not powerful, # we return False if n is # not 1. return (n == 1);# Function to perform dfsdef dfs(Node, parent): # Check if weight of # the current Node # is a powerful number global ans; if (isPowerful(weight[Node])): ans += 1; for to in graph[Node]: if (to == parent): continue; dfs(to, Node);# Driver codeif __name__ == '__main__': # Weights of the Node weight[1] = 5; weight[2] = 10; weight[3] = 11; weight[4] = 8; weight[5] = 6; # Edges of the tree graph[1].append(2); graph[2].append(3); graph[2].append(4); graph[1].append(5); dfs(1, 1); print(ans);# This code is contributed by 29AjayKumar |
C#
// C# implementation to count the // nodes in thegiven tree whose weight // is a powerful numberusing System;using System.Collections.Generic;class GFG{static int ans = 0;static List<int>[] graph = new List<int>[100];static int[] weight = new int[100];// Function to check if the number // is powerfulstatic bool isPowerful(int n) { // First divide the number // repeatedly by 2 while (n % 2 == 0) { int power = 0; while (n % 2 == 0) { n /= 2; power++; } // Check if only 2^1 divides n, // then return false if (power == 1) return false; } // Check if n is not a power of 2 // then this loop will execute for(int factor = 3; factor <= Math.Sqrt(n); factor += 2) { // Find highest power of "factor" // that divides n int power = 0; while (n % factor == 0) { n = n / factor; power++; } // Check if only factor^1 divides n, // then return false if (power == 1) return false; } // n must be 1 now // if it is not a prime number. // Since prime numbers are not powerful, // we return false if n is not 1. return (n == 1);}// Function to perform dfsstatic void dfs(int node, int parent) { // Check if weight of the current node // is a powerful number if (isPowerful(weight[node])) ans += 1; foreach (int to in graph[node]) { if (to == parent) continue; dfs(to, node); }}// Driver codepublic static void Main(String[] args){ for(int i = 0; i < graph.Length; i++) graph[i] = new List<int>(); // Weights of the node weight[1] = 5; weight[2] = 10; weight[3] = 11; weight[4] = 8; weight[5] = 6; // Edges of the tree graph[1].Add(2); graph[2].Add(3); graph[2].Add(4); graph[1].Add(5); dfs(1, 1); Console.Write(ans);}}// This code is contributed by amal kumar choubey |
Javascript
<script>// Javascript implementation to Count the nodes in the// given tree whose weight is a powerful numbervar ans = 0;var graph = Array.from(Array(100), ()=>Array());var weight = Array.from(Array(100), ()=>Array());// Function to check if the number is powerfulfunction isPowerful(n){ // First divide the number repeatedly by 2 while (n % 2 == 0) { var power = 0; while (n % 2 == 0) { n /= 2; power++; } // Check if only 2^1 divides n, // then return false if (power == 1) return false; } // Check if n is not a power of 2 // then this loop will execute for (var factor = 3; factor <= Math.sqrt(n); factor += 2) { // Find highest power of "factor" // that divides n var power = 0; while (n % factor == 0) { n = n / factor; power++; } // Check if only factor^1 divides n, // then return false if (power == 1) return false; } // n must be 1 now // if it is not a prime number. // Since prime numbers are not powerful, // we return false if n is not 1. return (n == 1);}// Function to perform dfsfunction dfs(node, parent){ // Check if weight of the current node // is a powerful number if (isPowerful(weight[node])) ans += 1; graph[node].forEach(to => { if (to != parent) dfs(to, node); });}// Driver code// Weights of the nodeweight[1] = 5;weight[2] = 10;weight[3] = 11;weight[4] = 8;weight[5] = 6;// Edges of the treegraph[1].push(2);graph[2].push(3);graph[2].push(4);graph[1].push(5);dfs(1, 1);document.write( ans);</script> |
Output:
1
Complexity Analysis:
Time Complexity: O(N*logV) where V is the maximum weight of a node in the tree
In dfs, every node of the tree is processed once, and hence the complexity due to the dfs is O(N) if there are total N nodes in the tree. Also, while processing every node, in order to check if the node value is a powerful number or not, the isPowerful(V) function where V is the weight of the node is being called and this function has a complexity of O(logV), hence for every node, there is an added complexity of O(logV). Therefore, the time complexity is O(N*logV).
Auxiliary Space: O(N).
Feeling lost in the world of random DSA topics, wasting time without progress? It’s time for a change! Join our DSA course, where we’ll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!
