从根到顶点的路径上的节点和相应邻居的总和 V

给定一个有N个顶点的有根树，一个数组values[ ] ，它代表分配给每个节点的值，以及一个顶点V ，任务是计算节点和位于从根开始的路径中的直接邻居的值的总和(总是0 ) 到V 。

例子：

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

方法：

这个想法是将每个节点的父节点存储在一个数组中，并将每个父节点的值与其子节点相加，然后将其存储在父节点中。现在，每个节点将保存其值和相应邻居值的总和。使用此数组查找从根到顶点V所需的路径总和。

请按照以下步骤解决问题：

• 使用 DFS 遍历初始化一个数组以存储每个节点及其相应邻居的值。
• 使用数组从顶点V迭代到根，并继续添加在路径上找到的所有节点的值。
• 最后，打印得到的sum 。

下面是上述方法的实现：

C++

// C++ Program to implement
// the above appraoch
#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 &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 valuesFromChildren(vector parent,
                               vector values)
{
  vector 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 parent,
                    vector 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 values = {1, 2, 3, 0, 0, 4, 3, 6};
 
  // Constructing the tree
  // using adjacency list
  vector> adjl = constructTree(n, edges);
 
  // Parent array
  vector parent(n);
 
  // store values in the parent array
  DFS(adjl, parent, 0, -1);
 
  // Add values of children to the parent
  vector 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 appraoch
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);
    }
}

C#

// C# program to implement
// the above appraoch
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());
    }
 
    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

输出：

16

时间复杂度： O(N)
辅助空间： O(N)

如果您想与行业专家一起参加直播课程，请参阅Geeks Classes Live