# Find the root of the sub-tree whose weighted sum is minimum

• Last Updated : 12 Jun, 2021

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:
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.

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`

## Javascript

 ``

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :