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

• Difficulty Level : Easy
• Last Updated : 23 Sep, 2021

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:

## C++

 `// C++ Program to implement``// the above approach``#include ``using` `namespace` `std;` `// Creating Adjacency list``vector> constructTree(``int` `n,``                                  ``vector> edges)``{``  ``vector> adjl(n);` `  ``for` `(``auto` `e : edges)``  ``{``    ``int` `u = e[0];``    ``int` `v = e[1];``    ``adjl[u].push_back(v);``    ``adjl[v].push_back(u);``  ``}``  ``return` `adjl;``}` `// Function to perform DFS traversal``void` `DFS(vector> adjl,``         ``vector<``int``> &parent, ``int` `u, ``int` `p)``{``  ` `  ``// Initializing parent of each node to p``  ``parent[u] = p;` `  ``// Iterate over the children``  ``for` `(``int` `v : adjl[u])``  ``{``    ``if` `(v != p)``    ``{``      ``DFS(adjl, parent, v, u);``    ``}``  ``}``}` `// Function to add values of children to``// respective parent nodes``vector<``int``> valuesFromChildren(vector<``int``> parent,``                               ``vector<``int``> values)``{``  ``vector<``int``> valuesChildren(parent.size());` `  ``for` `(``int` `i = 0; i < parent.size(); 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``int` `findSumOfValues(``int` `v, vector<``int``> parent,``                    ``vector<``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``int` `main()``{``  ``int` `n = 8;` `  ``// Insert edges into the graph``  ``vector> edges = {{0, 1}, {0, 2}, {0, 3}, {1, 4},``                               ``{1, 5}, {4, 7}, {3, 6}};` `  ``int` `v = 7;` `  ``// Values assigned to each vertex``  ``vector<``int``> values = {1, 2, 3, 0, 0, 4, 3, 6};` `  ``// Constructing the tree``  ``// using adjacency list``  ``vector> adjl = constructTree(n, edges);` `  ``// Parent array``  ``vector<``int``> parent(n);` `  ``// store values in the parent array``  ``DFS(adjl, parent, 0, -1);` `  ``// Add values of children to the parent``  ``vector<``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];``  ``cout << sum << endl;``}` `// This code is contributed by``// sanjeev2552`

## Java

 `// Java Program to implement``// the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Creating Adjacency list``    ``private` `static` `List >``    ``constructTree(``int` `n, ``int``[][] edges)``    ``{` `        ``List > adjl``            ``= ``new` `ArrayList >();` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``adjl.add(``new` `ArrayList());``        ``}` `        ``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 > 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 > 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);``    ``}``}`

## Python3

 `# Python3 program to implement the above approach` `# Creating Adjacency list``def` `constructTree(n, edges):``    ``adjl ``=` `[]`` ` `    ``for` `i ``in` `range``(n):``        ``adjl.append([])`` ` `    ``for` `i ``in` `range``(``len``(edges)):``        ``u ``=` `edges[i][``0``]``        ``v ``=` `edges[i][``1``]``        ``adjl[u].append(v)``        ``adjl[v].append(u)``    ``return` `adjl`` ` `# Function to perform DFS traversal``def` `DFS(adjl, parent, u, p):``  ` `    ``# Initializing parent of each node to p``    ``parent[u] ``=` `p`` ` `    ``# Iterate over the children``    ``for` `v ``in` `adjl[u]:``        ``if` `(v !``=` `p):``            ``DFS(adjl, parent, v, u)`` ` `# Function to add values of children to``# respective parent nodes``def` `valuesFromChildren(parent, values):``    ``valuesChildren ``=` `[``0``]``*``(``len``(parent))`` ` `    ``for` `i ``in` `range``(``len``(parent)):``        ``# Root node``        ``if` `(parent[i] ``=``=` `-``1``):``            ``continue``        ``else``:``            ``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``def` `findSumOfValues(v, parent, valuesChildren):``    ``cur_node ``=` `v``    ``Sum` `=` `0`` ` `    ``# Path from node V to root node``    ``while` `(cur_node !``=` `-``1``):``        ``Sum` `+``=` `valuesChildren[cur_node]``        ``cur_node ``=` `parent[cur_node]``    ``return` `Sum` `n ``=` `8`` ` `# Insert edges into the graph``edges ``=` `[ [ ``0``, ``1` `], [ ``0``, ``2` `], [ ``0``, ``3` `], [ ``1``, ``4` `], [ ``1``, ``5` `], [ ``4``, ``7` `], [ ``3``, ``6` `] ]` `v ``=` `7` `# Values assigned to each vertex``values ``=` `[ ``1``, ``2``, ``3``, ``0``, ``0``, ``4``, ``3``, ``6` `]` `# Constructing the tree``# using adjacency list``adjl ``=` `constructTree(n, edges)` `# Parent array``parent ``=` `[``0``]``*``(n)` `# store values in the parent array``DFS(adjl, parent, ``0``, ``-``1``)` `# Add values of children to the parent``valuesChildren ``=` `valuesFromChildren(parent, values)` `# Find sum of nodes lying in the path``Sum` `=` `findSumOfValues(v, parent, valuesChildren)` `# Add root node since``# its value is not included yet``Sum` `+``=` `values[``0``]` `print``(``Sum``)` `# This code is contributed by suresh07.`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Creating Adjacency list``private` `static` `List> constructTree(``int` `n, ``int``[,] edges)``{``    ``List > adjl = ``new` `List >();` `    ``for``(``int` `i = 0; i < n; i++)``    ``{``        ` `        ``adjl.Add(``new` `List<``int``>());``    ``}` `    ``for``(``int` `i = 0; i < edges.GetLength(0); i++)``    ``{``        ``int` `u = edges[i, 0];``        ``int` `v = edges[i, 1];``        ``adjl[u].Add(v);``        ``adjl[v].Add(u);``    ``}` `    ``return` `adjl;``}` `// Function to perform DFS traversal``private` `static` `void` `DFS(List > adjl,``                        ``int``[] parent, ``int` `u, ``int` `p)``{``    ` `    ``// Initializing parent of each node to p``    ``parent[u] = p;` `    ``// Iterate over the children``    ``foreach``(``int` `v ``in` `adjl[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> 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];` `    ``Console.WriteLine(sum);``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output:

`16`

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

My Personal Notes arrow_drop_up