Skip to content
Related Articles

Related Articles

Improve Article
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 <bits/stdc++.h>
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<ll> 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<ll> 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<ll>::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<Integer> 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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :