# Count the nodes whose weight is a perfect square

• Last Updated : 20 Apr, 2021

Given a tree, and the weights of all the nodes, the task is to count the number of nodes whose weight is a perfect Square.
Examples:

Input:

Output:
Only the weights of nodes 1, 4 and 5 are perfect squares.

Approach: Perform dfs on the tree and for every node, check if it’s weight is a perfect square or not.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach` `#include ` `using` `namespace` `std;`   `int` `ans = 0;`   `vector<``int``> graph[100];` `vector<``int``> weight(100);`   `// Function that returns true` `// if n is a perfect square` `bool` `isPerfectSquare(``int` `n)` `{` `    ``double` `x = ``sqrt``(n);` `    ``if` `(``floor``(x) != ``ceil``(x))` `        ``return` `false``;` `    ``return` `true``;` `}`   `// Function to perform dfs` `void` `dfs(``int` `node, ``int` `parent)` `{` `    ``// If weight of the current node` `    ``// is a perfect square` `    ``if` `(isPerfectSquare(weight[node]))` `        ``ans += 1;`   `    ``for` `(``int` `to : graph[node]) {` `        ``if` `(to == parent)` `            ``continue``;` `        ``dfs(to, node);` `    ``}` `}`   `// Driver code` `int` `main()` `{` `    ``int` `x = 15;`   `    ``// Weights of the node` `    ``weight[1] = 4;` `    ``weight[2] = 5;` `    ``weight[3] = 3;` `    ``weight[4] = 25;` `    ``weight[5] = 16;` `    ``weight[6] = 30;`   `    ``// Edges of the tree` `    ``graph[1].push_back(2);` `    ``graph[2].push_back(3);` `    ``graph[2].push_back(4);` `    ``graph[1].push_back(5);` `    ``graph[5].push_back(6);`   `    ``dfs(1, 1);`   `    ``cout << ans;`   `    ``return` `0;` `}`

## Java

 `// Java implementation of the approach` `import` `java.util.*;`   `class` `GFG{` ` `  `static` `int` `ans = ``0``;` ` `  `static` `Vector[] graph = ``new` `Vector[``100``]; ` `static` `int``[] weight = ``new` `int``[``100``];` ` `  `// Function that returns true` `// if n is a perfect square` `static` `boolean` `isPerfectSquare(``int` `n)` `{` `    ``double` `x = Math.sqrt(n);` `    ``if` `(Math.floor(x) != Math.ceil(x))` `        ``return` `false``;` `    ``return` `true``;` `}` ` `  `// Function to perform dfs` `static` `void` `dfs(``int` `node, ``int` `parent)` `{` `    ``// If weight of the current node` `    ``// is a perfect square` `    ``if` `(isPerfectSquare(weight[node]))` `        ``ans += ``1``;` ` `  `    ``for` `(``int` `to : graph[node]) {` `        ``if` `(to == parent)` `            ``continue``;` `        ``dfs(to, node);` `    ``}` `}` ` `  `// Driver code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `x = ``15``;` `    ``for` `(``int` `i = ``0``; i < ``100``; i++) ` `        ``graph[i] = ``new` `Vector<>();` `    `  `    ``// Weights of the node` `    ``weight[``1``] = ``4``;` `    ``weight[``2``] = ``5``;` `    ``weight[``3``] = ``3``;` `    ``weight[``4``] = ``25``;` `    ``weight[``5``] = ``16``;` `    ``weight[``6``] = ``30``;` ` `  `    ``// Edges of the tree` `    ``graph[``1``].add(``2``);` `    ``graph[``2``].add(``3``);` `    ``graph[``2``].add(``4``);` `    ``graph[``1``].add(``5``);` `    ``graph[``5``].add(``6``);` ` `  `    ``dfs(``1``, ``1``);` ` `  `    ``System.out.print(ans); ` `}` `}`   `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach` `from` `math ``import` `*` `ans ``=` `0`   `graph ``=` `[[] ``for` `i ``in` `range``(``100``)]` `weight ``=` `[``0``] ``*` `100`   `# Function that returns true` `# if n is a perfect square` `def` `isPerfectSquare(n):` `    ``x ``=` `sqrt(n)` `    ``if` `(floor(x) !``=` `ceil(x)):` `        ``return` `False` `    ``return` `True`   `# Function to perform dfs` `def` `dfs(node, parent):` `    ``global` `ans` `    `  `    ``# If weight of the current node ` `    ``# is a perfect square` `    ``if` `(isPerfectSquare(weight[node])):` `        ``ans ``+``=` `1``;` `    `  `    ``for` `to ``in` `graph[node]:` `        ``if` `(to ``=``=` `parent):` `            ``continue` `        ``dfs(to, node)`   `# Driver code`   `x ``=` `15`   `# Weights of the node` `weight[``1``] ``=` `4` `weight[``2``] ``=` `5` `weight[``3``] ``=` `3` `weight[``4``] ``=` `25` `weight[``5``] ``=` `16` `weight[``6``] ``=` `30`   `# Edges of the tree` `graph[``1``].append(``2``)` `graph[``2``].append(``3``)` `graph[``2``].append(``4``)` `graph[``1``].append(``5``)` `graph[``5``].append(``6``)`   `dfs(``1``, ``1``)` `print``(ans)`   `# This code is contributed by SHUBHAMSINGH10`

## C#

 `// C# program for the above approach` `using` `System; ` `using` `System.Collections; ` `using` `System.Collections.Generic; ` `using` `System.Text; `   `class` `GFG{` `    `  `static` `int` `ans = 0;`   `static` `ArrayList[] graph = ``new` `ArrayList[100]; ` `static` `int``[] weight = ``new` `int``[100];`   `// Function that returns true` `// if n is a perfect square` `static` `bool` `isPerfectSquare(``int` `n)` `{` `    ``double` `x = Math.Sqrt(n);` `    `  `    ``if` `(Math.Floor(x) != Math.Ceiling(x))` `        ``return` `false``;` `        `  `    ``return` `true``;` `}`   `// Function to perform dfs` `static` `void` `dfs(``int` `node, ``int` `parent)` `{` `    `  `    ``// If weight of the current node` `    ``// is a perfect square` `    ``if` `(isPerfectSquare(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)` `{` `    ``//int x = 15;` `    ``for``(``int` `i = 0; i < 100; i++) ` `        ``graph[i] = ``new` `ArrayList();` `    `  `    ``// Weights of the node` `    ``weight[1] = 4;` `    ``weight[2] = 5;` `    ``weight[3] = 3;` `    ``weight[4] = 25;` `    ``weight[5] = 16;` `    ``weight[6] = 30;`   `    ``// Edges of the tree` `    ``graph[1].Add(2);` `    ``graph[2].Add(3);` `    ``graph[2].Add(4);` `    ``graph[1].Add(5);` `    ``graph[5].Add(6);`   `    ``dfs(1, 1);`   `    ``Console.Write(ans); ` `}` `}`   `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`3`

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) for N nodes in the tree. Also, while processing every node, in order to check if the node value is a perfect square or not, the inbuilt sqrt(V), is being called where V is the weight of the node and this function has a complexity of O(log V). Hence for every node, there is an added complexity of O(log V). Therefore, the total time complexity is O(N*logV).
• Auxiliary Space: O(1).
Any extra space is not required, so the space complexity is constant.

My Personal Notes arrow_drop_up
Recommended Articles
Page :