GFG App
Open App
Browser
Continue

# 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

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

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 never be 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 then 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 to 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.
• 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 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; }

## 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       # Print the 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.

## Javascript



Output:

1 2 2 2 2 1 1 1 1 1 2

Time Complexity: O(N), where N is the total number of nodes in the tree.
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up