Skip to content
Related Articles

Related Articles

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

View Discussion
Improve Article
Save Article
  • 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 <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;
}

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

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




<script>
 
// Javascript implementation to Count the nodes in the
// given tree whose weight is a powerful number
 
var ans = 0;
var graph = Array.from(Array(100), ()=>Array());
var weight = Array.from(Array(100), ()=>Array());
 
// Function to check if the number is powerful
function isPowerful(n)
{
    // First divide the number repeatedly by 2
    while (n % 2 == 0) {
        var 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 (var factor = 3; factor <= Math.sqrt(n); factor += 2) {
 
        // Find highest power of "factor"
        // that divides n
        var 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
function dfs(node, parent)
{
 
    // Check if weight of the current node
    // is a powerful number
    if (isPowerful(weight[node]))
        ans += 1;
    graph[node].forEach(to => {
         
        if (to != parent)
            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].push(2);
graph[2].push(3);
graph[2].push(4);
graph[1].push(5);
dfs(1, 1);
document.write( ans);
 
 
</script>

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.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!