# Count the nodes in the given tree whose weight is even

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

Input:

Output:
Only the weights of the nodes 2, 4 and 5 are even.

Approach: Perform dfs on the tree and for every node, check if it’s weight is divisible by 2 or not. If yes then increment count.

Algorithm:

Step 1: Start
Step 2: Create a global integer variable name it as “ans” and initialize it to 0.
Step 3: Create a vector of integer type name it as “weight” to store the weights of the nodes.
Step 4: Create a vector of integer type name it as “graph” to represent the tree.
Step 5: Create a static function of void return type name it as “dfs” which take node and its parent as input.
Step 6: The value of ans should be increased by one if the weight of the current node is even.
Step 7: Start a for loop for all graph node
a. if current node equal to parent then Recursively call the dfs function with the current node and the next node as n                    parameters.
Step 8: End

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 to perform dfs` `void` `dfs(``int` `node, ``int` `parent)` `{` `    ``// If weight of the current node is even` `    ``if` `(weight[node] % 2 == 0)` `        ``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] = 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 of the approach ` `import` `java.util.*; `   `class` `GFG ` `{ ` `    ``static` `int` `ans = ``0``; ` `    `  `    ``@SuppressWarnings``(``"unchecked"``) ` `    ``static` `Vector[] graph = ``new` `Vector[``100``]; ` `    ``static` `int``[] weight = ``new` `int``[``100``];` `    `  `    ``// Function to perform dfs ` `    ``static` `void` `dfs(``int` `node, ``int` `parent) ` `    ``{ ` `        ``// If weight of the current node is even ` `        ``if` `(weight[node] % ``2` `== ``0``) ` `            ``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``] = ``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.println(ans);` `    ``} ` `}`   `// This code is contributed by shubhamsingh10`

## Python3

 `# Python3 implementation of the approach` `ans ``=` `0`   `graph ``=` `[[] ``for` `i ``in` `range``(``100``)]` `weight ``=` `[``0``] ``*` `100`   `# Function to perform dfs` `def` `dfs(node, parent):` `    ``global` `ans` `    `  `    ``# If weight of the current node is even` `    ``if` `(weight[node] ``%` `2` `=``=` `0``):` `        ``ans ``+``=` `1` `    `  `    ``for` `to ``in` `graph[node]:` `        ``if` `(to ``=``=` `parent):` `            ``continue` `        ``dfs(to, node)`   `# Driver code` `x ``=` `15`   `# 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 SHUBHAMSINGH10`

## C#

 `// C# implementation of the approach ` `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 perform dfs ` `    ``static` `void` `dfs(``int` `node, ``int` `parent) ` `    ``{ ` `        ``// If weight of the current node is even ` `        ``if` `(weight[node] % 2 == 0) ` `            ``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 < 100; 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.WriteLine(ans);` `    ``} ` `}`   `// This code is contributed by Rajput-Ji`

## Javascript

 ``

Output:

`3`

Complexity Analysis:

• Time Complexity : O(N).
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. Therefore, the time complexity is O(N).
• Auxiliary Space : O(1).
Any extra space is not required, so the space complexity is constant.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next