# Count the nodes in the given tree whose weight is a powerful number

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.

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

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 ` `using` `namespace` `std; ` ` `  `int` `ans = 0; ` `vector<``int``> graph; ` `vector<``int``> weight(100); ` ` `  `// Function to check if the number is powerful ` `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 <= ``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 dfs ` `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 code ` `int` `main() ` `{ ` ` `  `    ``// Weights of the node ` `    ``weight = 5; ` `    ``weight = 10; ` `    ``weight = 11; ` `    ``weight = 8; ` `    ``weight = 6; ` ` `  `    ``// Edges of the tree ` `    ``graph.push_back(2); ` `    ``graph.push_back(3); ` `    ``graph.push_back(4); ` `    ``graph.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 number ` ` `  `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `static` `int` `ans = ``0``; ` `static` `Vector[] graph = ``new` `Vector[``100``]; ` `static` `int``[] weight = ``new` `int``[``100``]; ` ` `  `// Function to check if the number is powerful ` `static` `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 dfs ` `static` `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 code ` `public` `static` `void` `main(String[] args) { ` `         `  `    ``for` `(``int` `i = ``0``; i < graph.length; i++) ` `         ``graph[i] = ``new` `Vector(); ` `             `  `    ``// 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 `

## C#

 `// C# implementation to count the  ` `// nodes in thegiven tree whose weight  ` `// is a powerful number ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG{ ` ` `  `static` `int` `ans = 0; ` `static` `List<``int``>[] graph = ``new` `List<``int``>; ` `static` `int``[] weight = ``new` `int``; ` ` `  `// Function to check if the number  ` `// is powerful ` `static` `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 dfs ` `static` `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 code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``for``(``int` `i = 0; i < graph.Length; i++) ` `       ``graph[i] = ``new` `List<``int``>(); ` `             `  `    ``// Weights of the node ` `    ``weight = 5; ` `    ``weight = 10; ` `    ``weight = 11; ` `    ``weight = 8; ` `    ``weight = 6; ` ` `  `    ``// Edges of the tree ` `    ``graph.Add(2); ` `    ``graph.Add(3); ` `    ``graph.Add(4); ` `    ``graph.Add(5); ` ` `  `    ``dfs(1, 1); ` `    ``Console.Write(ans); ` `} ` `} ` ` `  `// This code is contributed by amal kumar choubey `

Output:

```1
```

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.