Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

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

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: 3 
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++ 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 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 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# 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


















                        






                        























                                    



                                    




                                    




                                    


                                



















<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(N).

	

        Article Tags : 
        

            Algorithms
DSA
Mathematical
Recursion
Tree        


		
	

	


      

      

          
Recommended Articles

      

      

          
          
1. Count number of paths whose weight is exactly X and has at-least one edge of weight M

          
2. Count nodes in the given tree whose weight is a fibonacci number

          
3. Count the nodes in the given Tree whose weight is a Perfect Number

          
4. Count of all prime weight nodes between given nodes in the given Tree

          
5. Count the nodes in the given tree whose weight is even

          
6. Count the nodes in the given tree whose weight is a power of two

          
7. Count the nodes in the given tree whose weight is even parity

          
8. Count the nodes in the given tree whose sum of digits of weight is odd

          
9. Count the nodes of the given tree whose weight has X as a factor

          
10. Count the nodes in the given tree whose weight is prime

          
11. Count the nodes whose weight is a perfect square

          
12. Maximize cost of segment having weight at most K from given weight and cost of N items

          
13. Choose maximum weight with given weight and value ratio

          
14. Construct a Tree whose sum of nodes of all the root to leaf path is not divisible by the count of nodes in that path

          
15. Count of Nodes which has Prime Digit sum weight in a Tree

          
16. Length of largest subarray whose all elements Powerful number

          
17. Query to find the maximum and minimum weight between two nodes in the given tree using LCA.

          
18. Construct an N-ary Tree having no pair of adjacent nodes with same weight from given weights

          
19. Count the nodes of the tree which make a pangram when concatenated with the sub-tree nodes

          
20. Count the nodes of a tree whose weighted string is an anagram of the given string

          
21. Count the nodes of the given tree whose weighted string is a palindrome

          
22. Count nodes with prime weight in a Directed Acyclic Graph

          
23. Count of nodes in a given N-ary tree having distance to all leaf nodes equal in their subtree

          
24. Comparison between Height Balanced Tree and Weight Balanced Tree

          
25. Count the nodes of the tree whose weighted string contains a vowel