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

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

Javascript

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

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)