Queries to calculate sum of the path from root to a given node in given Binary Tree

Given an infinite complete binary tree rooted at node 1, where every i^th node has two children, with values 2 * i and 2 * (i + 1). Given another array arr[] consisting of N positive integers, the task for each array element arr[i] is to find the sum of the node values that occur in a path from the root node to the node arr[i].

Examples:

Input: arr[] = {3, 10}
Output: 4 18
Explanation:
Node 3: The path is 3 -> 1. Therefore, the sum of the path is 4.
Node 10: The path is 10 -> 5 -> 2 -> 1. Therefore, the sum of node is 18.

Input: arr[] = {1, 4, 20}
Output: 1 7 38
Explanation:
Node 1: The path is 1. Therefore, the sum of the path is 1.
Node 4: The path is 4 -> 2 -> 1. Therefore, the sum of node is 7.
Node 20: The path is 20 -> 10 -> 5 -> 2 -> 1. Therefore, the sum of node is 38.

Naive Approach: The simplest approach is to perform DFS Traversal for each array element arr[i] to find its path from the current node to the root and print the sum of the node values in that path. 
Time Complexity: O(N * H), where H is the maximum height of the tree.
Auxiliary Space: O(H)

Optimized Approach: In this approach we will be creating a function to find the sum of node values along the path for each element in the given array arr[] and a function to find the sum of node values along the path from the root node to a given node.

Step by step algorithm:

1. Initialize sum to 0.
2. Traverse the binary tree from the given node to the root node.
3. At each node, add the node value to the sum.
4. Update the current node to its parent node.
5. Repeat steps 3-4 until the current node is the root node.
6. Add the root node value to the sum.
7. Return the sum.

#include <bits/stdc++.h>
using namespace std;

// Function to find the sum of node values along the path
// from the root node to a given node
int findPathSum(int n) {
    int sum = 0;
    while (n != 1) {
        sum += n;
        n /= 2;
    }
    sum += 1; // Add the root node value
    return sum;
}

// Function to find the sum of node values along the path
// for each element in the given array arr[]
vector<int> findPathSums(vector<int>& arr) {
    vector<int> pathSums;
    for (int n : arr) {
        int pathSum = findPathSum(n);
        pathSums.push_back(pathSum);
    }
    return pathSums;
}

// Driver code
int main() {

    vector<int> arr = {1, 4, 20};
    vector<int> pathSums = findPathSums(arr);
    for (int sum : pathSums) {
        cout << sum << " ";
    }
    cout << endl;

    return 0;
}

import java.util.*;

public class Main {
    // Function to find the sum of node values along the path
    // from the root node to a given node
    static int findPathSum(int n) {
        int sum = 0;
        while (n != 1) {
            sum += n;
            n /= 2;
        }
        sum += 1; // Add the root node value
        return sum;
    }

    // Function to find the sum of node values along the path
    // for each element in the given array arr[]
    static List<Integer> findPathSums(List<Integer> arr) {
        List<Integer> pathSums = new ArrayList<>();
        for (int n : arr) {
            int pathSum = findPathSum(n);
            pathSums.add(pathSum);
        }
        return pathSums;
    }

    // Driver code
    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(1, 4, 20);
        List<Integer> pathSums = findPathSums(arr);
        for (int sum : pathSums) {
            System.out.print(sum + " ");
        }
        System.out.println();
    }
}

# Function to find the sum of node values along the path
# from the root node to a given node
def find_path_sum(n):
    sum = 0
    while n != 1:
        sum += n
        n //= 2
    sum += 1  # Add the root node value
    return sum

# Function to find the sum of node values along the path
# for each element in the given array arr[]
def find_path_sums(arr):
    path_sums = []
    for n in arr:
        path_sum = find_path_sum(n)
        path_sums.append(path_sum)
    return path_sums

# Driver code
if __name__ == "__main__":
    arr = [1, 4, 20]
    path_sums = find_path_sums(arr)
    for sum in path_sums:
        print(sum, end=" ")
    print()

using System;
using System.Collections.Generic;

class GFG {
    // Function to find the sum of node values along the
    // path from the root node to a given node
    static int findPathSum(int n)
    {
        int sum = 0;
        while (n != 1) {
            sum += n;
            n /= 2;
        }
        sum += 1; // Add the root node value
        return sum;
    }

    // Function to find the sum of node values along the
    // path for each element in the given array arr[]
    static List<int> findPathSums(List<int> arr)
    {
        List<int> pathSums = new List<int>();
        foreach(int n in arr)
        {
            int pathSum = findPathSum(n);
            pathSums.Add(pathSum);
        }
        return pathSums;
    }

    // Driver code
    public static void Main(string[] args)
    {
        List<int> arr = new List<int>{ 1, 4, 20 };
        List<int> pathSums = findPathSums(arr);
        foreach(int sum in pathSums)
        {
            Console.Write(sum + " ");
        }
        Console.WriteLine();
    }
}

// Function to find the sum of node values along the path
// from the root node to a given node
function findPathSum(n) {
    let sum = 0;
    while (n !== 1) {
        sum += n;
        n = Math.floor(n / 2);
    }
    sum += 1; // Add the root node value
    return sum;
}

// Function to find the sum of node values along the path
// for each element in the given array arr[]
function findPathSums(arr) {
    const pathSums = [];
    for (const n of arr) {
        const pathSum = findPathSum(n);
        pathSums.push(pathSum);
    }
    return pathSums;
}

// Driver code
const arr = [1, 4, 20];
const pathSums = findPathSums(arr);

// Print the path sums on the same line
console.log(pathSums.join(" "));

1 7 38 

Time complexity: O(NlogN), where N is the number of elements in the given array arr. 

Auxiliary Space: O(N), where N is the number of elements in the given array arr. 

Efficient Approach: The above approach can also be optimized based on the observation that the parent of the node with value N contains the value N/2. Follow the steps below to solve the problem:

• Initialize a variable, say sumOfNode, to store the sum of nodes in a path.
• Traverse the array arr[i] and perform the following steps:
  • For each element arr[i], update the value of sumOfNode as sumOfNode + X and update arr[i] as arr[i] / 2.
  • Repeat the above steps while arr[i] is greater than 0.
  • Print the value of sumOfNode as the result for each array element arr[i].

Below is the implementation of the above approach:

// C++ program for the above approach
#include <iostream>
#include <vector>
using namespace std;

// Function to find the sum of the
// path from root to the current node
void sumOfNodeInAPath(int node_value)
{
    // Sum of nodes in the path
    int sum_of_node = 0;

    // Iterate until root is reached
    while (node_value) {

        sum_of_node += node_value;

        // Update the node value
        node_value /= 2;
    }

    // Print the resultant sum
    cout << sum_of_node;

    return;
}

// Function to print the path
// sum for each query
void findSum(vector<int> Q)
{
    // Traverse the queries
    for (int i = 0; i < Q.size(); i++) {

        int node_value = Q[i];

        sumOfNodeInAPath(node_value);

        cout << " ";
    }
}

// Driver Code
int main()
{
    vector<int> arr = { 1, 5, 20, 100 };
    findSum(arr);

    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;
import java.util.ArrayList;
class GFG {

  // Function to find the sum of the
  // path from root to the current node
  public static void sumOfNodeInAPath(int node_value)
  {
    // Sum of nodes in the path
    int sum_of_node = 0;

    // Iterate until root is reached
    while (node_value > 0) {

      sum_of_node += node_value;

      // Update the node value
      node_value /= 2;
    }

    // Print the resultant sum
    System.out.print(sum_of_node);
  }

  // Function to print the path
  // sum for each query
  public static void findSum(ArrayList<Integer> Q)
  {
    // Traverse the queries
    for (int i = 0; i < Q.size(); i++) {

      int node_value = Q.get(i);

      sumOfNodeInAPath(node_value);

      System.out.print(" ");
    }
  }

  // Driver Code
  public static void main(String[] args)
  {
    // arraylist to store integers
    ArrayList<Integer> arr = new ArrayList<>();
    arr.add(1);
    arr.add(5);
    arr.add(20);
    arr.add(100);
    findSum(arr);
  }
}

// This code is contributed by aditya7409.

# Python program for the above approach

# Function to find the sum of the
# path from root to the current node
def sumOfNodeInAPath(node_value):
    
    # Sum of nodes in the path
    sum_of_node = 0
    
    # Iterate until root is reached
    while (node_value):
        
        sum_of_node += node_value
        
        # Update the node value
        node_value //= 2
        
    # Print the resultant sum
    print(sum_of_node, end = " ")
    
# Function to print the path
# sum for each query
def findSum(Q):
    
    # Traverse the queries
    for i in range(len(Q)):
        node_value = Q[i]
        sumOfNodeInAPath(node_value)
        print(end = "")

# Driver Code
arr = [1, 5, 20, 100] 
findSum(arr)

# This code is contributed by shubhamsingh10

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

  // Function to find the sum of the
  // path from root to the current node
  public static void sumOfNodeInAPath(int node_value)
  {
    
    // Sum of nodes in the path
    int sum_of_node = 0;

    // Iterate until root is reached
    while (node_value > 0) {

      sum_of_node += node_value;

      // Update the node value
      node_value /= 2;
    }

    // Print the resultant sum
    Console.Write(sum_of_node);
  }

  // Function to print the path
  // sum for each query
  public static void findSum(List<int> Q)
  {
    // Traverse the queries
    for (int i = 0; i < Q.Count ; i++) {

      int node_value = Q[i];
      sumOfNodeInAPath(node_value);
      Console.Write(" ");
    }
  }

// Driver Code
static public void Main()
{
  
    // arraylist to store integers
    List<int> arr = new List<int>();
    arr.Add(1);
    arr.Add(5);
    arr.Add(20);
    arr.Add(100);
    findSum(arr);
}
}
// This code is contributed by sanjoy_62.

<script>

// JavaScript program to count frequencies of array items

// Function to find the sum of the
// path from root to the current node
function sumOfNodeInAPath(node_value)
{
    // Sum of nodes in the path
    let sum_of_node = 0;

    // Iterate until root is reached
    while (node_value) {

        sum_of_node += node_value;

        // Update the node value
        node_value = Math.floor(node_value / 2 );
    }

    // Print the resultant sum
    document.write(sum_of_node);

    return;
}

// Function to print the path
// sum for each query
function findSum( Q)
{
    // Traverse the queries
    for (let i = 0; i < Q.length; i++) {

        let node_value = Q[i];

        sumOfNodeInAPath(node_value);

        document.write(" ");
    }
}


// Driver Code

let arr = [ 1, 5, 20, 100 ];
findSum(arr);

</script>

1 8 38 197

Time Complexity: O(N*log X), where X is the maximum element of the array.
Auxiliary Space: O(1)