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

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


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

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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.