# 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:
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 ``using` `namespace` `std;` `int` `ans = 0;``vector<``int``> graph[100];``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[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 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`

## Python3

 `# Python3 implementation to``# Count the Nodes in the given``# tree whose weight is a powerful ``# number``graph ``=` `[[] ``for` `i ``in` `range``(``100``)]``weight ``=` `[``0``] ``*` `100``ans ``=` `0` `# Function to check if the ``# number is powerful``def` `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 dfs``def` `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 code``if` `__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 number``using` `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 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[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

 ``

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).

Previous
Next