Skip to content
Related Articles

Related Articles

Count the nodes in the given tree whose weight is a powerful number
  • Last Updated : 09 Nov, 2020

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation to Count the nodes in the
// given tree whose weight is a powerful number
 
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

//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<Integer>[] 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<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 is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :