Given an N-ary tree consisting of **N** nodes numbered from **1 to N** rooted at **node 1**, the task is to assign values to each node of the tree such that the sum of values from any root to the leaf path which contains at least two nodes is not divisible by the number of nodes along that path.

**Examples:**

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 1Explanation: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

**Approach:** The given problem can be solved based on the observation that for any root to leaf path with a number of nodes **at least 2**, say **K** if the sum of values along this path lies between **K** and **2*K** exclusive then that sum can be never divisible by **K** as any number over the range **(K, 2*K)** is never divisible by **K**. Therefore, for **K = 1**, assign node values of odd level nodes as **1**, and rest as **2**. Follow the steps below to solve the problem:

- Initialize an array, say
**answer[]**of size**N + 1**to store the values assigned to the nodes. - Initialize a variable say
**K**as**1**to assign values to each node. - Initialize a queue that is used to perform BFS Traversal on the given tree and push node with value 1 in the queue and initialize the value to the nodes as
**1**. - Iterate until the queue is non-empty and perform the following steps:
- Pop the front node of the queue and if the value assigned to the popped node is
**1**then update the value of**K**as**2**. Otherwise, update**K**as**1**. - Traverse all the child nodes of the current popped node and push the child node in the queue and assigned the value
**K**to the child node.

- Pop the front node of the queue and if the value assigned to the popped node is
- After completing the above steps, print the values stored in the array
**answer[]**as the result.

Below is the implementation of the above approach:

## 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 <` `int` `> 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 <` `bool` `> visited(n + 1, ` `false` `);` ` ` `// Stores the node values` ` ` `vector <` `int` `> answer(n + 1);` ` ` `// Variable used to assign values to` ` ` `// the nodes alternatively to the` ` ` `// parent child` ` ` `int` `K = 1;` ` ` `// Declare a queue` ` ` `queue <` `int` `> 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<ArrayList<Integer>> 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<Integer> 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.` |

**Output:**

1 2 2 2 2 1 1 1 1 1 2

**Time Complexity:** O(V + E)**Auxiliary Space:** O(V + E)

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. Get hold of all the important mathematical concepts for competitive programming with the **Essential Maths for CP Course** at a student-friendly price.

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**