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++ 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 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 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# 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[1] = 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. |
<script> // Javascript program for the above approach // 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 function assignValues(Edges, n)
{ // Stores the adjacency list
var tree = Array.from(Array(n+1), ()=> Array());
// Create a adjacency list
for ( var i = 0; i < n - 1; i++) {
var u = Edges[i][0];
var v = Edges[i][1];
tree[u].push(v);
tree[v].push(u);
}
// Stores whether node is
// visited or not
var visited = Array(n + 1).fill( false );
// Stores the node values
var answer = Array(n + 1);
// Variable used to assign values to
// the nodes alternatively to the
// parent child
var K = 1;
// Declare a queue
var q = [];
// Push the 1st node
q.push(1);
// Assign K value to this node
answer[1] = K;
while (q.length!=0) {
// Dequeue the node
var node = q[0];
q.shift();
// Mark it as visited
visited[node] = true ;
// Upgrade the value of K
K = ((answer[node] == 1) ? 2 : 1);
// Assign K to the child nodes
tree[node].forEach(child => {
// 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 ( var i = 1; i <= n; i++) {
document.write( answer[i] + " " );
}
} // Driver Code var N = 11;
var 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); </script> |
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)