鉴于由N N叉树节点编号从1到N节点1根，任务是分配值给树的每个节点，使得值的总和从任何根，其含有至少两个叶路径节点不能被该路径上的节点数整除。
例子：
Input: N = 11, edges[][] = {{1, 2}, {1, 3}, {1, 4}, {1, 5}, {2, 6}, {2, 10}, {10, 11}, {3, 7}, {4, 8}, {5, 9}}
Output: 1 2 1 2 2 1 1
Explanation:
According to the above assignment of values, below are all the possible paths from the root to leaf:
- Path 1 → 2 → 6, sum = 1 + 2 + 1 = 4, length = 3.
- Path 1 → 2 → 10 → 11, sum = 1 + 2 + 1 + 2 = 6, length = 4
- Path 1 → 3 → 7, sum = 1 + 2 + 1 = 4, length = 3.
- Path 1 → 4 → 8, sum = 1 + 2 + 1 = 4, length = 3.
- Path 1 → 5 → 9, sum = 1 + 2 + 1 = 4, length = 3.
From all the above paths, none of the paths exists having the sum of values divisible by their length.
Input: N = 3, edges = {{1, 2}, {2, 3}}
Output: 1 2 1
方法：给定的问题可以基于以下观察结果来解决：对于具有至少2个节点的任何根到叶的路径，将其表示为K(如果沿着该路径的值之和位于K与2 * K之间)，则该和可以永远不会被K整除，因为(K，2 * K)范围内的任何数字都不会被K整除。因此，对于K = 1 ，将奇数级节点的节点值分配为1 ，其余部分分配为2 。请按照以下步骤解决问题：
- 初始化一个数组，说出大小为N + 1的answer []以存储分配给节点的值。
- 将变量K初始化为1，以将值分配给每个节点。
- 初始化用于在给定树上执行BFS遍历的队列，并将节点中的值为1的节点推送到队列中，并将该节点的值初始化为1 。
- 迭代直到队列为非空，然后执行以下步骤：
- 弹出队列的前端节点，如果分配给弹出节点的值为1，则将K的值更新为2 。否则，将K更新为1 。
- 遍历当前弹出节点的所有子节点，并将该子节点推送到队列中，并将值K分配给该子节点。
- 完成上述步骤后，打印存储在数组answer []中的值作为结果。
下面是上述方法的实现：
C++
// C++ program for the above approach
#include "bits/stdc++.h"
using namespace std;
// Function to assign values to nodes
// of the tree s.t. sum of values of
// nodes of path between any 2 nodes
// is not divisible by length of path
void assignValues(int Edges[][2], int n)
{
// Stores the adjacency list
vector tree[n + 1];
// Create a adjacency list
for(int i = 0; i < n - 1; i++) {
int u = Edges[i][0];
int v = Edges[i][1];
tree[u].push_back(v);
tree[v].push_back(u);
}
// Stores whether node is
// visited or not
vector visited(n + 1, false);
// Stores the node values
vector answer(n + 1);
// Variable used to assign values to
// the nodes alternatively to the
// parent child
int K = 1;
// Declare a queue
queue q;
// Push the 1st node
q.push(1);
// Assign K value to this node
answer[1] = K;
while (!q.empty()) {
// Dequeue the node
int node = q.front();
q.pop();
// Mark it as visited
visited[node] = true;
// Upgrade the value of K
K = ((answer[node] == 1) ? 2 : 1);
// Assign K to the child nodes
for (auto child : tree[node]) {
// If the child is unvisited
if (!visited[child]) {
// Enqueue the child
q.push(child);
// Assign K to the child
answer[child] = K;
}
}
}
// Print the value assigned to
// the nodes
for (int i = 1; i <= n; i++) {
cout << answer[i] << " ";
}
}
// Driver Code
int main()
{
int N = 11;
int Edges[][2] = {{1, 2}, {1, 3}, {1, 4},
{1, 5}, {2, 6}, {2, 10},
{10, 11}, {3, 7}, {4, 8},
{5, 9}};
// Function Call
assignValues(Edges, N);
return 0;
} Java
// Java program for the above approach
import java.util.*;
class GFG{
// Function to assign values to nodes
// of the tree s.t. sum of values of
// nodes of path between any 2 nodes
// is not divisible by length of path
static void assignValues(int Edges[][], int n)
{
// Stores the adjacency list
ArrayList> tree = new ArrayList<>();
for(int i = 0; i < n + 1; i++)
tree.add(new ArrayList<>());
// Create a adjacency list
for(int i = 0; i < n - 1; i++)
{
int u = Edges[i][0];
int v = Edges[i][1];
tree.get(u).add(v);
tree.get(v).add(u);
}
// Stores whether node is
// visited or not
boolean[] visited = new boolean[n + 1];
// Stores the node values
int[] answer = new int[n + 1];
// Variable used to assign values to
// the nodes alternatively to the
// parent child
int K = 1;
// Declare a queue
Queue q = new LinkedList<>();
// Push the 1st node
q.add(1);
// Assign K value to this node
answer[1] = K;
while (!q.isEmpty())
{
// Dequeue the node
int node = q.peek();
q.poll();
// Mark it as visited
visited[node] = true;
// Upgrade the value of K
K = ((answer[node] == 1) ? 2 : 1);
// Assign K to the child nodes
for(Integer child : tree.get(node))
{
// If the child is unvisited
if (!visited[child])
{
// Enqueue the child
q.add(child);
// Assign K to the child
answer[child] = K;
}
}
}
// Print the value assigned to
// the nodes
for(int i = 1; i <= n; i++)
{
System.out.print(answer[i] + " ");
}
}
// Driver code
public static void main(String[] args)
{
int N = 11;
int Edges[][] = { { 1, 2 }, { 1, 3 },
{ 1, 4 }, { 1, 5 },
{ 2, 6 }, { 2, 10 },
{ 10, 11 }, { 3, 7 },
{ 4, 8 }, { 5, 9 } };
// Function Call
assignValues(Edges, N);
}
}
// This code is contributed by offbeat Python3
# Python3 program for the above approach
from collections import deque
# Function to assign values to nodes
# of the tree s.t. sum of values of
# nodes of path between any 2 nodes
# is not divisible by length of path
def assignValues(Edges, n):
# Stores the adjacency list
tree = [[] for i in range(n + 1)]
# Create a adjacency list
for i in range(n - 1):
u = Edges[i][0]
v = Edges[i][1]
tree[u].append(v)
tree[v].append(u)
# Stores whether any node is
# visited or not
visited = [False]*(n+1)
# Stores the node values
answer = [0]*(n + 1)
# Variable used to assign values to
# the nodes alternatively to the
# parent child
K = 1
# Declare a queue
q = deque()
# Push the 1st node
q.append(1)
# Assign K value to this node
answer[1] = K
while (len(q) > 0):
# Dequeue the node
node = q.popleft()
# q.pop()
# Mark it as visited
visited[node] = True
# Upgrade the value of K
K = 2 if (answer[node] == 1) else 1
# Assign K to the child nodes
for child in tree[node]:
# If the child is unvisited
if (not visited[child]):
# Enqueue the child
q.append(child)
# Assign K to the child
answer[child] = K
# Prthe value assigned to
# the nodes
for i in range(1, n + 1):
print(answer[i],end=" ")
# Driver Code
if __name__ == '__main__':
N = 7
Edges = [ [ 1, 2 ], [ 4, 6 ],
[ 3, 5 ], [ 1, 4 ],
[ 7, 5 ], [ 5, 1 ] ]
# Function Call
assignValues(Edges, N)
# This code is contributed by mohit kumar 29.输出：
1 2 2 2 2 1 1 1 1 1 2时间复杂度： O(V + E)
辅助空间： O(V + E)