Skip to content
Related Articles

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :