给定一棵树，以及所有节点的权重，任务是计算权重为有效数的节点数。
A number n is said to be Powerful Number if, for every prime factor p of it, p2 also divides it.
例子：
Input:
Output: 3
Explanation:
4, 16 and 25 are powerful weights in the tree.
方法：要解决上述问题，我们必须在树上执行深度优先搜索(DFS)，对于每个节点，检查其权重是否为有效数字。如果是，则增加计数。
下面是上述方法的实现：
C++
// C++ implementation to Count the nodes in the
// given tree whose weight is a powerful number
#include
using namespace std;
int ans = 0;
vector graph[100];
vector 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[] 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();
// 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 29AjayKumarC#
// 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[] graph = new List[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();
// 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 输出：
1
复杂度分析：
时间复杂度： O(N * logV)其中V是树中节点的最大权重
在dfs中，树的每个节点都处理一次，因此，如果树中总共有N个节点，则由于dfs而导致的复杂度为O(N)。另外，在处理每个节点时，为了检查节点值是否为整数，将调用isPowerful(V)函数(其中V为节点的权重)，该函数的复杂度为O(logV) ，因此对于每个节点，都会增加O(logV)的复杂度。因此，时间复杂度为O(N * logV)。
辅助空间： O(1)。
不需要任何额外的空间，因此空间复杂度是恒定的。