Given a **tree**, and the **weights** of all the nodes, the task is to count the number of nodes whose weight is a **Perfect number**.

A

perfect numberis a positive integer that is equal to the sum of its proper divisors.

**Examples:**

Input:

Output:0Explanation:

There is no node with a weight that is a perfect number.

**Approach:**

In order to solve this problem, we perform Depth First Search(DFS) Traversal on the tree and for every node, check if its weight is a Perfect Number or not. We keep on incrementing the counter every time such a weight is obtained. The final value of that counter after the completion of the entire tree traversal is the answer.

Below is the implementation of the above approach:

## C++

`// C++ implementation to Count the nodes in the` `// given tree whose weight is a Perfect Number` `#include <bits/stdc++.h>` `using` `namespace` `std;` `int` `ans = 0;` `vector<` `int` `> graph[100];` `vector<` `int` `> weight(100);` `// Function that returns true if n is perfect` `bool` `isPerfect(` `long` `long` `int` `n)` `{` ` ` `// Variable to store sum of divisors` ` ` `long` `long` `int` `sum = 1;` ` ` `// Find all divisors and add them` ` ` `for` `(` `long` `long` `int` `i = 2; i * i <= n; i++) {` ` ` `if` `(n % i == 0) {` ` ` `if` `(i * i != n)` ` ` `sum = sum + i + n / i;` ` ` `else` ` ` `sum = sum + i;` ` ` `}` ` ` `}` ` ` `// Check if sum of divisors is equal to` ` ` `// n, then n is a perfect number` ` ` `if` `(sum == n && n != 1)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Function to perform dfs` `void` `dfs(` `int` `node, ` `int` `parent)` `{` ` ` `// If weight of the current node` ` ` `// is a perfect number` ` ` `if` `(isPerfect(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;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java implementation to Count the nodes in the` `// given tree whose weight is a Perfect Number` `import` `java.util.*;` `class` `GFG{` `static` `int` `ans = ` `0` `;` `static` `Vector<Integer> []graph = ` `new` `Vector[` `100` `];` `static` `int` `[]weight = ` `new` `int` `[` `100` `];` `// Function that returns true if n is perfect` `static` `boolean` `isPerfect(` `int` `n)` `{` ` ` `// Variable to store sum of divisors` ` ` `int` `sum = ` `1` `;` ` ` `// Find all divisors and add them` ` ` `for` `(` `int` `i = ` `2` `; i * i <= n; i++) {` ` ` `if` `(n % i == ` `0` `) {` ` ` `if` `(i * i != n)` ` ` `sum = sum + i + n / i;` ` ` `else` ` ` `sum = sum + i;` ` ` `}` ` ` `}` ` ` `// Check if sum of divisors is equal to` ` ` `// n, then n is a perfect number` ` ` `if` `(sum == n && n != ` `1` `)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Function to perform dfs` `static` `void` `dfs(` `int` `node, ` `int` `parent)` `{` ` ` `// If weight of the current node` ` ` `// is a perfect number` ` ` `if` `(isPerfect(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<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 contributed by Princi Singh` |

*chevron_right*

*filter_none*

## Python3

`# Python3 implementation to ` `# Count the Nodes in the given ` `# tree whose weight is a Perfect ` `# Number` `graph ` `=` `[[] ` `for` `i ` `in` `range` `(` `100` `)]` `weight ` `=` `[` `0` `] ` `*` `100` `ans ` `=` `0` `# Function that returns ` `# True if n is perfect` `def` `isPerfect(n):` ` ` ` ` `# Variable to store ` ` ` `# sum of divisors` ` ` `sum` `=` `1` `;` ` ` `# Find all divisors ` ` ` `# and add them` ` ` `i ` `=` `2` `;` ` ` ` ` `while` `(i ` `*` `i < n):` ` ` `if` `(n ` `%` `i ` `=` `=` `0` `):` ` ` `if` `(i ` `*` `i !` `=` `n):` ` ` `sum` `=` `sum` `+` `i ` `+` `n ` `/` `i;` ` ` `else` `:` ` ` `sum` `=` `sum` `+` `i;` ` ` `i ` `+` `=` `1` `;` ` ` `# Check if sum of divisors ` ` ` `# is equal to n, then n is ` ` ` `# a perfect number` ` ` `if` `(` `sum` `=` `=` `n ` `and` `n !` `=` `1` `):` ` ` `return` `True` `;` ` ` `return` `False` `;` `# Function to perform dfs` `def` `dfs(Node, parent):` ` ` ` ` `# If weight of the current` ` ` `# Node is a perfect number` ` ` `global` `ans;` ` ` ` ` `if` `(isPerfect(weight[Node])):` ` ` `ans ` `+` `=` `1` `;` ` ` `for` `to ` `in` `graph[Node]:` ` ` `if` `(to ` `=` `=` `parent):` ` ` `continue` `;` ` ` `dfs(to, Node);` `# Driver code` `# 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` |

*chevron_right*

*filter_none*

## C#

`// C# implementation to count the ` `// nodes in the given tree whose ` `// weight is a Perfect 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 that returns true ` `// if n is perfect` `static` `bool` `isPerfect(` `int` `n)` `{` ` ` ` ` `// Variable to store sum of` ` ` `// divisors` ` ` `int` `sum = 1;` ` ` `// Find all divisors and add them` ` ` `for` `(` `int` `i = 2; i * i <= n; i++) ` ` ` `{` ` ` `if` `(n % i == 0) ` ` ` `{` ` ` `if` `(i * i != n)` ` ` `sum = sum + i + n / i;` ` ` `else` ` ` `sum = sum + i;` ` ` `}` ` ` `}` ` ` `// Check if sum of divisors is equal ` ` ` `// to n, then n is a perfect number` ` ` `if` `(sum == n && n != 1)` ` ` `return` `true` `;` ` ` `return` `false` `;` `}` `// Function to perform dfs` `static` `void` `dfs(` `int` `node, ` `int` `parent)` `{` ` ` `// If weight of the current node` ` ` `// is a perfect number` ` ` `if` `(isPerfect(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` |

*chevron_right*

*filter_none*

**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 perfect number or not, the isPerfect(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.