Related Articles
Find the root of the sub-tree whose weighted sum is minimum
• Last Updated : 14 Jun, 2020

Given a tree, and the weights of all the nodes, the task is to find the root of the sub-tree whose weighted sum is minimum.

Examples:

Input: Output: 5
Weight of sub-tree for parent 1 = ((-1) + (5) + (-2) + (-1) + (3)) = 4
Weight of sub-tree for parent 2 = ((5) + (-1) + (3)) = 7
Weight of sub-tree for parent 3 = -1
Weight of sub-tree for parent 4 = 3
Weight of sub-tree for parent 5 = -2
Node 5 gives the minimum sub-tree weighted sum.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: Perform dfs on the tree, and for every node calculate the sub-tree weighted sum rooted at the current node then find the minimum sum value for a node.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `int` `ans = 0, mini = INT_MAX;`` ` `vector<``int``> graph;``vector<``int``> weight(100);`` ` `// Function to perform dfs and update the tree``// such that every node's weight is the sum of``// the weights of all the nodes in the sub-tree``// of the current node including itself``void` `dfs(``int` `node, ``int` `parent)``{``    ``for` `(``int` `to : graph[node]) {``        ``if` `(to == parent)``            ``continue``;``        ``dfs(to, node);`` ` `        ``// Calculating the weighted``        ``// sum of the subtree``        ``weight[node] += weight[to];``    ``}``}`` ` `// Function to find the node``// having minimum sub-tree sum``void` `findMin(``int` `n)``{`` ` `    ``// For every node``    ``for` `(``int` `i = 1; i <= n; i++) {`` ` `        ``// If current node's weight``        ``// is minimum so far``        ``if` `(mini > weight[i]) {``            ``mini = weight[i];``            ``ans = i;``        ``}``    ``}``}`` ` `// Driver code``int` `main()``{``    ``int` `n = 5;`` ` `    ``// Weights of the node``    ``weight = -1;``    ``weight = 5;``    ``weight = -1;``    ``weight = 3;``    ``weight = -2;`` ` `    ``// Edges of the tree``    ``graph.push_back(2);``    ``graph.push_back(3);``    ``graph.push_back(4);``    ``graph.push_back(5);`` ` `    ``dfs(1, 1);``    ``findMin(n);`` ` `    ``cout << ans;`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach ``import` `java.util.*; `` ` `class` `GFG ``{ ``    ``static` `int` `ans = ``0``, mini = Integer.MAX_VALUE; ``     ` `    ``@SuppressWarnings``(``"unchecked"``)``    ``static` `Vector[] graph = ``new` `Vector[``100``]; ``    ``static` `Integer[] weight = ``new` `Integer[``100``]; `` ` `    ``// Function to perform dfs and update the tree ``    ``// such that every node's weight is the sum of ``    ``// the weights of all the nodes in the sub-tree ``    ``// of the current node including itself ``    ``static` `void` `dfs(``int` `node, ``int` `parent) ``    ``{ ``        ``for` `(``int` `to : graph[node]) ``        ``{ ``            ``if` `(to == parent) ``                ``continue``; ``            ``dfs(to, node); `` ` `            ``// Calculating the weighted ``            ``// sum of the subtree ``            ``weight[node] += weight[to]; ``        ``} ``    ``} `` ` `    ``// Function to find the node ``    ``// having minimum sub-tree sum  x ``    ``static` `void` `findMin(``int` `n) ``    ``{ `` ` `        ``// For every node ``        ``for` `(``int` `i = ``1``; i <= n; i++) ``        ``{ `` ` `            ``// If current node's weight  x ``            ``// is minimum so far ``            ``if` `(mini > weight[i]) ``            ``{ ``                ``mini = weight[i]; ``                ``ans = i; ``            ``} ``        ``} ``    ``} `` ` `    ``// Driver code ``    ``public` `static` `void` `main(String[] args) ``    ``{ ``         ` `        ``int` `n = ``5``; ``        ``for` `(``int` `i = ``0``; i < ``100``; i++) ``            ``graph[i] = ``new` `Vector(); ``         ` `        ``// Weights of the node ``        ``weight[``1``] = -``1``; ``        ``weight[``2``] = ``5``; ``        ``weight[``3``] = -``1``; ``        ``weight[``4``] = ``3``; ``        ``weight[``5``] = -``2``; `` ` `        ``// Edges of the tree ``        ``graph[``1``].add(``2``); ``        ``graph[``2``].add(``3``); ``        ``graph[``2``].add(``4``); ``        ``graph[``1``].add(``5``); `` ` `        ``dfs(``1``, ``1``); ``        ``findMin(n); `` ` `        ``System.out.print(ans); ``    ``} ``} `` ` `// This code is contributed by shubhamsingh10 `

## C#

 `// C# implementation of the approach ``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG ``{ ``    ``static` `int` `ans = 0, mini = ``int``.MaxValue; `` ` `    ``static` `List<``int``>[] graph = ``new` `List<``int``>; ``    ``static` `int``[] weight = ``new` `int``; ``  ` `    ``// Function to perform dfs and update the tree ``    ``// such that every node's weight is the sum of ``    ``// the weights of all the nodes in the sub-tree ``    ``// of the current node including itself ``    ``static` `void` `dfs(``int` `node, ``int` `parent) ``    ``{ ``        ``foreach` `(``int` `to ``in` `graph[node]) ``        ``{ ``            ``if` `(to == parent) ``                ``continue``; ``            ``dfs(to, node); ``  ` `            ``// Calculating the weighted ``            ``// sum of the subtree ``            ``weight[node] += weight[to]; ``        ``} ``    ``} ``  ` `    ``// Function to find the node ``    ``// having minimum sub-tree sum  x ``    ``static` `void` `findMin(``int` `n) ``    ``{ ``  ` `        ``// For every node ``        ``for` `(``int` `i = 1; i <= n; i++) ``        ``{ ``  ` `            ``// If current node's weight  x ``            ``// is minimum so far ``            ``if` `(mini > weight[i]) ``            ``{ ``                ``mini = weight[i]; ``                ``ans = i; ``            ``} ``        ``} ``    ``} ``  ` `    ``// Driver code ``    ``public` `static` `void` `Main(String[] args) ``    ``{ ``          ` `        ``int` `n = 5; ``        ``for` `(``int` `i = 0; i < 100; i++) ``            ``graph[i] = ``new` `List<``int``>(); ``          ` `        ``// Weights of the node ``        ``weight = -1; ``        ``weight = 5; ``        ``weight = -1; ``        ``weight = 3; ``        ``weight = -2; ``  ` `        ``// Edges of the tree ``        ``graph.Add(2); ``        ``graph.Add(3); ``        ``graph.Add(4); ``        ``graph.Add(5); ``  ` `        ``dfs(1, 1); ``        ``findMin(n); ``  ` `        ``Console.Write(ans); ``    ``} ``} `` ` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 implementation of the approach``ans ``=` `0``mini ``=` `2``*``*``32`` ` `graph ``=` `[[] ``for` `i ``in` `range``(``100``)] ``weight ``=` `[``0``]``*``100`` ` `# Function to perform dfs and update the tree``# such that every node's weight is the sum of``# the weights of all the nodes in the sub-tree``# of the current node including itself``def` `dfs(node, parent):``    ``global` `mini, graph, weight, ans ``    ``for` `to ``in` `graph[node]: ``        ``if` `(to ``=``=` `parent): ``            ``continue``        ``dfs(to, node) ``         ` `        ``# Calculating the weighted ``        ``# sum of the subtree ``        ``weight[node] ``+``=` `weight[to] ``     ` `# Function to find the node``# having minimum sub-tree sum``def` `findMin(n):``    ``global` `mini, graph, weight, ans ``     ` `    ``# For every node``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``         ` `        ``# If current node's weight``        ``# is minimum so far``        ``if` `(mini > weight[i]):``            ``mini ``=` `weight[i]``            ``ans ``=` `i`` ` `# Driver code``n ``=` `5`` ` `# Weights of the node``weight[``1``] ``=` `-``1``weight[``2``] ``=` `5``weight[``3``] ``=` `-``1``weight[``4``] ``=` `3``weight[``5``] ``=` `-``2`` ` `# Edges of the tree``graph[``1``].append(``2``)``graph[``2``].append(``3``)``graph[``2``].append(``4``)``graph[``1``].append(``5``)`` ` `dfs(``1``, ``1``)``findMin(n)`` ` `print``(ans)`` ` `# This code is contributed by SHUBHAMSINGH10`
Output:
```5
```

Complexity Analysis:

• Time Complexity : O(N).
In dfs, every node of the tree is processed once and hence the complexity due to the dfs is O(N) if there are total N nodes in the tree. Therefore, the time complexity is O(N).
• Auxiliary Space : O(n).
Recursion stack.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up