Related Articles

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

• Last Updated : 03 Jun, 2021

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

Any extra space is not required, so the space complexity is constant.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up