# Path from the root node to a given node in an N-ary Tree

• Difficulty Level : Medium
• Last Updated : 19 Jan, 2021

Given an integer N and an N-ary Tree of the following form:

• Every node is numbered sequentially, starting from 1, till the last level, which contains the node N.
• The nodes at every odd level contains 2 children and nodes at every even level contains 4 children.

The task is to print the path from the root node to the node N.

Examples:

Input: N = 14

Output: 1 2 5 14
Explanation: The path from node 1 to node 14 is 1 – > 2 – > 5 – > 14.

Input: N = 11
Output: 1 3 11
Explanation: The path from node 1 to node 11 is 1 – > 3 – > 11.

Approach: Follow the steps below to solve the problem:

• Initialize an array to store the number of nodes present in each level of the Tree, i.e. {1, 2, 8, 16, 64, 128 â€¦.} and store it.
• Calculate prefix sum of the array i.e. {1 3 11 27 91 219 â€¦â€¦.}
• Find the index ind in the prefix sum array which exceeds or is equal to N using lower_bound(). Therefore, ind indicates the number of levels that need to be traversed to reach node N.
• Initialize a variable say, temp = N and an array path[] to store the nodes from root to N.
• Decrement ind until it is less than or equal to 1 and keep updating val = temp â€“ prefix[ind â€“ 1].
• Update temp = prefix[ind â€“ 2] + (val + 1) / 2 if ind is odd.
• Otherwise, update temp = prefix[ind â€“ 2] + (val + 3) / 4 if ind is even.
• Append temp into the path[] array.
• Finally, print the array, path[].

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;``typedef` `long` `long` `ll;` `// Function to find the path``// from root to N``void` `PrintPathNodes(ll N)``{` `    ``// Stores the number of``    ``// nodes at (i + 1)-th level``    ``vector arr;``    ``arr.push_back(1);` `    ``// Stores the number of nodes``    ``ll k = 1;` `    ``// Stores if the current``    ``// level is even or odd``    ``bool` `flag = ``true``;` `    ``while` `(k < N) {` `        ``// If level is odd``        ``if` `(flag == ``true``) {``            ``k *= 2;``            ``flag = ``false``;``        ``}` `        ``// If level is even``        ``else` `{` `            ``k *= 4;``            ``flag = ``true``;``        ``}` `        ``// If level with``        ``// node N is reached``        ``if` `(k > N) {``            ``break``;``        ``}` `        ``// Push into vector``        ``arr.push_back(k);``    ``}` `    ``ll len = arr.size();``    ``vector prefix(len);``    ``prefix[0] = 1;` `    ``// Compute prefix sums of count``    ``// of nodes in each level``    ``for` `(ll i = 1; i < len; ++i) {``        ``prefix[i] = arr[i] + prefix[i - 1];``    ``}` `    ``vector::iterator it``        ``= lower_bound(prefix.begin(),``                      ``prefix.end(), N);` `    ``// Stores the level in which``    ``// node N s present``    ``ll ind = it - prefix.begin();` `    ``ll temp = N;` `    ``// Store path``    ``vector<``int``> path;` `    ``path.push_back(N);` `    ``while` `(ind > 1) {``        ``ll val = temp - prefix[ind - 1];` `        ``if` `(ind % 2 != 0) {``            ``temp = prefix[ind - 2]``                   ``+ (val + 1) / 2;``        ``}``        ``else` `{``            ``temp = prefix[ind - 2]``                   ``+ (val + 3) / 4;``        ``}``        ``--ind;` `        ``// Insert temp into path``        ``path.push_back(temp);``    ``}` `    ``if` `(N != 1)``        ``path.push_back(1);` `    ``// Print path``    ``for` `(``int` `i = path.size() - 1;``         ``i >= 0; i--) {` `        ``cout << path[i] << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{` `    ``ll N = 14;` `    ``// Function Call``    ``PrintPathNodes(N);` `    ``return` `0;``}`

## Python3

 `# Python3 program for the above approach``from` `bisect ``import` `bisect_left` `# Function to find the path``# from root to N``def` `PrintPathNodes(N):` `    ``# Stores the number of``    ``# nodes at (i + 1)-th level``    ``arr ``=` `[]``    ``arr.append(``1``)` `    ``# Stores the number of nodes``    ``k ``=` `1` `    ``# Stores if the current``    ``# level is even or odd``    ``flag ``=` `True``    ``while` `(k < N):` `        ``# If level is odd``        ``if` `(flag ``=``=` `True``):``            ``k ``*``=` `2``            ``flag ``=` `False` `        ``# If level is even``        ``else``:``            ``k ``*``=` `4``            ``flag ``=` `True` `        ``# If level with``        ``# node N is reached``        ``if` `(k > N):``            ``break` `        ``# Push into vector``        ``arr.append(k)``    ``lenn ``=` `len``(arr)``    ``prefix ``=` `[``0``]``*``(lenn)``    ``prefix[``0``] ``=` `1` `    ``# Compute prefix sums of count``    ``# of nodes in each level``    ``for` `i ``in` `range``(``1``,lenn):``        ``prefix[i] ``=` `arr[i] ``+` `prefix[i ``-` `1``]``    ``it ``=` `bisect_left(prefix, N)` `    ``# Stores the level in which``    ``# node N s present``    ``ind ``=` `it``    ``temp ``=` `N` `    ``# Store path``    ``path ``=` `[]``    ``path.append(N)``    ``while` `(ind > ``1``):``        ``val ``=` `temp ``-` `prefix[ind ``-` `1``]` `        ``if` `(ind ``%` `2` `!``=` `0``):``            ``temp ``=` `prefix[ind ``-` `2``] ``+` `(val ``+` `1``) ``/``/` `2``        ``else``:``            ``temp ``=` `prefix[ind ``-` `2``] ``+` `(val ``+` `3``) ``/``/` `4``        ``ind ``-``=` `1` `        ``# Insert temp into path``        ``path.append(temp)``    ``if` `(N !``=` `1``):``        ``path.append(``1``)` `    ``# Print path``    ``for` `i ``in` `range``(``len``(path)``-``1``, ``-``1``, ``-``1``):``        ``print``(path[i], end``=``" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `14` `    ``# Function Call``    ``PrintPathNodes(N)` `    ``# This code is contributed by mohit kumar 29`

Output:

`1 2 5 14`

Time Complexity: O(log(N))
Auxiliary Space: O(log(N))

My Personal Notes arrow_drop_up