Sum of Nodes and respective Neighbors on the path from root to a vertex V

Given a rooted tree having N vertices, an array values[ ], which represents the value assigned to each node, and a vertex V, the task is to calculate the sum of values of nodes and immediate neighbors lying in the path from the root(always 0) to V.

Examples:

Input: N = 8, values = {1, 2, 3, 0, 0, 4, 3, 6}, V = 7

Output: 16
Explanation:
Path from root (0) to V (7) = 0 -> 1 -> 4 -> 7
Neighbors of 0 = (2, 3), Sum = 1(node 0) + 3(node 2) + 0(node 3) = 4
Neighbors of 1 = (5), Sum = 2(node 1) + 4(node 5) = 6
No neighbor of 4, Sum = 0(node 4) = 0
No neighbor of 7, Sum = 6(node 7) = 6
Total sum = 4 + 6 + 0 + 6 = 16

Input: N = 5, values = {5, 6, 2, 9, 0}, V = 2

Output: 13

Approach:



The idea is to store the parent of each node in an array and add the value of each parent with its child and store it in the parent node. Now, each node will hold sum of its value and value of corresponding neighbors. Use this array to find the required sum of the path from root to vertex V.

Follow the steps below to solve the problem:

  • Initialize an array to store the values of each node and its corresponding neighbors using DFS Traversal.
  • Iterate from vertex V to root using the array and keep adding the value of all the nodes found on the path.
  • Finally, print the obtained sum.

Below is the implementation of the above approach:

Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to implement
// the above appraoch
import java.io.*;
import java.util.*;
  
class GFG {
  
    // Creating Adjacency list
    private static List<List<Integer> >
    constructTree(int n, int[][] edges)
    {
  
        List<List<Integer> > adjl
            = new ArrayList<List<Integer> >();
  
        for (int i = 0; i < n; i++) {
  
            adjl.add(new ArrayList<Integer>());
        }
  
        for (int[] e : edges) {
            int u = e[0];
            int v = e[1];
            adjl.get(u).add(v);
            adjl.get(v).add(u);
        }
  
        return adjl;
    }
  
    // Function to perform DFS traversal
    private static void DFS(
        List<List<Integer> > adjl,
        int[] parent, int u, int p)
    {
  
        // Initializing parent of each node to p
        parent[u] = p;
  
        // Iterate over the children
        for (int v : adjl.get(u)) {
  
            if (v != p) {
  
                DFS(adjl, parent, v, u);
            }
        }
    }
  
    // Function to add values of children to
    // respective parent nodes
    private static int[] valuesFromChildren(
        int[] parent, int[] values)
    {
  
        int[] valuesChildren
            = new int[parent.length];
  
        for (int i = 0; i < parent.length; i++) {
  
            // Root node
            if (parent[i] == -1)
                continue;
  
            else {
                int p = parent[i];
  
                valuesChildren[p] += values[i];
            }
        }
        return valuesChildren;
    }
  
    // Function to return sum of values of
    // each node in path from V to the root
    private static int findSumOfValues(
        int v, int[] parent,
        int[] valuesChildren)
    {
  
        int cur_node = v;
        int sum = 0;
  
        // Path from node V to root node
        while (cur_node != -1) {
  
            sum += valuesChildren[cur_node];
            cur_node = parent[cur_node];
        }
  
        return sum;
    }
  
    // Driver Code
    public static void main(String[] args)
    {
  
        int n = 8;
  
        // Insert edges into the graph
        int[][] edges = { { 0, 1 },
                          { 0, 2 },
                          { 0, 3 },
                          { 1, 4 },
                          { 1, 5 },
                          { 4, 7 },
                          { 3, 6 } };
  
        int v = 7;
  
        // Values assigned to each vertex
        int[] values = new int[] { 1, 2, 3, 0,
                                   0, 4, 3, 6 };
  
        // Constructing the tree
        // using adjacency list
        List<List<Integer> > adjl
            = constructTree(n, edges);
  
        // Parent array
        int[] parent = new int[n];
  
        // store values in the parent array
        DFS(adjl, parent, 0, -1);
  
        // Add values of children to the parent
        int[] valuesChildren
            = valuesFromChildren(parent, values);
  
        // Find sum of nodes lying in the path
        int sum = findSumOfValues(
            v, parent,
            valuesChildren);
  
        // Add root node since
        // its value is not included yet
        sum += values[0];
  
        System.out.println(sum);
    }
}

chevron_right


Output:

16

Time Complexity: O(N)
Auxiliary Space: O(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

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.