Related Articles

# 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

• Difficulty Level : Hard
• Last Updated : 11 Aug, 2021

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[], ``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];``      ``int` `v = Edges[i];``      ``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 = 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[] = {{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` `    ``# 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.`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections;``using` `System.Collections.Generic;` `public` `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``      ``LinkedList<``int``>[] tree = ``new` `LinkedList<``int``>[n+1];` `    ``for``(``int` `i = 0; i < n + 1; i++)``        ``tree[i] = ``new` `LinkedList<``int``>();` `    ``// Create a adjacency list``    ``for``(``int` `i = 0; i < n - 1; i++)``    ``{``        ``int` `u = Edges[i, 0];``        ``int` `v = Edges[i, 1];``        ``tree[u].AddLast(v);``        ``tree[v].AddLast(u);``    ``}` `    ``// Stores whether node is``    ``// visited or not``    ``bool``[] visited = ``new` `bool``[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` `Queue();` `    ``// Push the 1st node``    ``q.Enqueue(1);` `    ``// Assign K value to this node``    ``answer = K;` `    ``while` `(q.Count > 0)``    ``{` `        ``// Dequeue the node``        ``int` `node = (``int``)q.Peek();``        ``q.Dequeue();` `        ``// Mark it as visited``        ``visited[node] = ``true``;` `        ``// Upgrade the value of K``        ``K = ((answer[node] == 1) ? 2 : 1);` `        ``// Assign K to the child nodes``        ``foreach` `(``var` `child ``in` `tree[node])``        ``{``    ` `            ``// If the child is unvisited``            ``if` `(!visited[child])``            ``{``                ` `                ``// Enqueue the child``                ``q.Enqueue(child);` `                ``// Assign K to the child``                ``answer[child] = K;``            ``}``        ``}``    ``}` `    ``// Print the value assigned to``    ``// the nodes``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``           ``Console.Write(answer[i] + ``" "``);``    ``}``}` `// Driver code``static` `public` `void` `Main (){` `    ``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 Dharanendra L V.`

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