Related Articles
Sum of nodes in the path from root to N-th node in given Tree
• Difficulty Level : Hard
• Last Updated : 23 Nov, 2020

Given an integer N which needs to be present as a value in a node in the last level of a Tree rooted at 1 having nodes numbered from root to the last level by increments of 1. The nodes at every odd level contain 2 children and nodes at every even level contains 4 children. The task is to find the sum of node values in the path from the root to the node N.

Examples:

Input: N = 13

Output: 20
Explanation: The traversal from root 1 to node 13 is 1 -> 2 ->  4 -> 13. Therefore, sum of all nodes in the path = 1 + 2 + 4 + 13 = 20.

Input: N = 124
Output: 193
Explanation: The traversal from root 1 to node 124 is 1 -> 2 -> 6 -> 16 -> 44 -> 124. Therefore, sum of all nodes in the path = 1 + 2 + 6 + 16 + 44 + 124 = 193.

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 temp = N and two variables final_ans = 0 and val.
• Decrement ind until until it is less than or equal to 1 and keep updating val = temp – prefix[ind – 1].
• Update temp to prefix[ind – 2] + (val + 1) / 2 if ind is odd.
• Otherwise, update prefix[ind – 2] + (val + 3) / 4 if ind is even.
• After completing the above steps, add N + 1 to final_ans and pint it as the required answer.

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 sum of all``// nodes from root to N``ll sumOfPathNodes(ll N)``{` `    ``// If N is equal to 1``    ``if` `(N == 1) {``        ``return` `1;``    ``}` `    ``// If N is equal to 2 or 3``    ``else` `if` `(N == 2 || N == 3) {``        ``return` `N + 1;``    ``}` `    ``// 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();` `    ``// Stores the required sum``    ``ll final_ans = 0;``    ``ll temp = 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;` `        ``// Add temp to the sum``        ``final_ans += temp;``    ``}` `    ``final_ans += (N + 1);` `    ``return` `final_ans;``}` `// Driver Code``int` `main()``{` `    ``ll N = 13;` `    ``// Function Call``    ``cout << sumOfPathNodes(N) << endl;` `    ``return` `0;``}`

## Java

 `// Java program for the``// above approach``import` `java.util.*;``class` `GFG{` `// Function to find sum of``// aint nodes from root to N``static` `int` `sumOfPathNodes(``int` `N)``{``  ``// If N is equal to 1``  ``if` `(N == ``1``)``  ``{``    ``return` `1``;``  ``}` `  ``// If N is equal to``  ``// 2 or 3``  ``else` `if` `(N == ``2` `||``           ``N == ``3``)``  ``{``    ``return` `N + ``1``;``  ``}` `  ``// Stores the number of``  ``// nodes at (i + 1)-th level``  ``Vector arr =``         ``new` `Vector<>();``  ``arr.add(``1``);` `  ``// Stores the number``  ``// of nodes``  ``int` `k = ``1``;` `  ``// Stores if the current``  ``// level is even or odd``  ``boolean` `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.add(k);``  ``}` `  ``int` `len = arr.size();``  ``int``[] prefix = ``new` `int``[len];``  ``prefix[``0``] = ``1``;` `  ``// Compute prefix sums of``  ``// count of nodes in each``  ``// level``  ``for` `(``int` `i = ``1``; i < len; ++i)``  ``{``    ``prefix[i] = arr.get(i) +``                ``prefix[i - ``1``];``  ``}` `  ``int` `it = lowerBound(prefix, ``0``,``                      ``len, N) + ``1``;` `  ``// Stores the level in which``  ``// node N s present``  ``int` `ind = it - prefix[``0``];` `  ``// Stores the required sum``  ``int` `final_ans = ``0``;``  ``int` `temp = N;` `  ``while` `(ind > ``1``)``  ``{``    ``int` `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;` `    ``// Add temp to the sum``    ``final_ans += temp;``  ``}` `  ``final_ans += (N + ``1``);``  ``return` `final_ans;``}``  ` `static` `int` `lowerBound(``int``[] a, ``int` `low,``                      ``int` `high, ``int` `element)``{``  ``while``(low < high)``  ``{``    ``int` `middle = low +``                 ``(high - low) / ``2``;``    ` `    ``if``(element > a[middle])``      ``low = middle + ``1``;``    ``else``      ``high = middle;``  ``}``  ``return` `low;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``int` `N = ``13``;` `  ``// Function Call``  ``System.out.print(``  ``sumOfPathNodes(N) + ``"\n"``);``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach``from` `bisect ``import` `bisect_left, bisect` `# Function to find sum of all``# nodes from root to N``def` `sumOfPathNodes(N):``    ` `    ``# If N is equal to 1``    ``if` `(N ``=``=` `1``):``        ``return` `1` `    ``# If N is equal to 2 or 3``    ``elif` `(N ``=``=` `2` `or` `N ``=``=` `3``):``        ``return` `N ``+` `1``        ` `    ``# 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 leve 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` `    ``# Stores the required sum``    ``final_ans ``=` `0``    ``temp ``=` `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` `        ``# Add temp to the sum``        ``final_ans ``+``=` `temp` `    ``final_ans ``+``=` `(N ``+` `1``)` `    ``return` `final_ans` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `13` `    ``# Function Call``    ``print``(sumOfPathNodes(N))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the``// above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to find sum of``// aint nodes from root to N``static` `int` `sumOfPathNodes(``int` `N)``{``  ` `  ``// If N is equal to 1``  ``if` `(N == 1)``  ``{``    ``return` `1;``  ``}` `  ``// If N is equal to``  ``// 2 or 3``  ``else` `if` `(N == 2 ||``           ``N == 3)``  ``{``    ``return` `N + 1;``  ``}` `  ``// Stores the number of``  ``// nodes at (i + 1)-th level``  ``List<``int``> arr = ``new` `List<``int``>();``  ``arr.Add(1);` `  ``// Stores the number``  ``// of nodes``  ``int` `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.Add(k);``  ``}` `  ``int` `len = arr.Count;``  ``int``[] prefix = ``new` `int``[len];``  ``prefix[0] = 1;` `  ``// Compute prefix sums of``  ``// count of nodes in each``  ``// level``  ``for``(``int` `i = 1; i < len; ++i)``  ``{``    ``prefix[i] = arr[i] +``                ``prefix[i - 1];``  ``}` `  ``int` `it = lowerBound(prefix, 0,``                      ``len, N) + 1;``  ` `  ``// Stores the level in which``  ``// node N s present``  ``int` `ind = it - prefix[0];` `  ``// Stores the required sum``  ``int` `final_ans = 0;``  ``int` `temp = N;` `  ``while` `(ind > 1)``  ``{``    ``int` `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;``    ` `    ``// Add temp to the sum``    ``final_ans += temp;``  ``}``  ``final_ans += (N + 1);``  ` `  ``return` `final_ans;``}``  ` `static` `int` `lowerBound(``int``[] a, ``int` `low,``                      ``int` `high, ``int` `element)``{``  ``while``(low < high)``  ``{``    ``int` `middle = low +``                 ``(high - low) / 2;``    ` `    ``if` `(element > a[middle])``      ``low = middle + 1;``    ``else``      ``high = middle;``  ``}``  ``return` `low;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``  ``int` `N = 13;``  ` `  ``// Function Call``  ``Console.Write(sumOfPathNodes(N) + ``"\n"``);``}``}` `// This code is contributed by Amit Katiyar`
Output:
```20

```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up