# Maximum sum possible for every node by including it in a segment of N-Ary Tree

Given an N-Ary tree containing N nodes and an array weight [ ] that denotes the weight of the nodes which can be positive or negative, the task for every node is to print the maximum sum possible by a sequence of nodes including the current node.

Examples:

```Input: N = 7
weight[] = [-8, 9, 7, -4, 5, -10, -6]
N-Ary tree:
-8
/   \
9      7
/  \    /
-4    5 -10
/
-6
Output: 13 14 13 10 14 3 4

Explanations:
Node -8: [-8 + 9 + 7 + 5] = 13
Node 9: [9 + 5] = 14
Node 3: [7 + (-8) + 9 + 5] = 13
Node 4: [-4 + 9 + 5] = 10
Node: [5 + 9] = 14
Node 6: [-10 + 7 + (-8) + 9 + 5] = 3
Node 7: [-6 + (-4) + 9 + 5] = 4

Input: N = 6
weight[] = [2, -7, -5, 8, 4, -10]
N-Ary tree:
2
/   \
-7    -5
/ \     \
8   4    -10
Output: 7 7 2 8 7 -8
```

Approach:This problem can be solved using Dp on Trees technique by applying two DFS.

• Apply the first DFS to store the maximum sum possible for every node by including them in a sequence with their respective successors. Store the maximum possible sum in dp1[]. array.
• Maximum possible value for each node in the first DFS can be obtained by:

dp1[node] += maximum(0, dp1[child1], dp1[child2], …)

• Perform the second Dfs to update the maximum sum for each node in dp1[] by including them in a sequence with their ancestors also. The maximum values stored in dp2[] for every node are the required answers.
• Maximum possible value for each node in the second DFS can be obtained by:

dp2[node] = dp1[node] + maximum(0, maxSumAncestors)
Best answer can be obtained by including or excluding the maximum sum possible for its ancestors
where maxSumAncestors = dp2[parent] – maximum(0, dp1[node]), i.e. including or excluding contribution of the maximum sum of the current node stored in dp1[]

• Refer to the pictorial explanation for better understanding:

Below is the implementation of the above approach:

## C++

 `// C++ program to calculate the maximum ` `// sum possible for every node by including ` `// it in a segment of the N-Ary Tree ` `#include ` `using` `namespace` `std; ` ` `  `// Stores the maximum ` `// sum possible for every node ` `// by including them in a segment ` `// with their successors ` `int` `dp1[100005]; ` ` `  `// Stores the maximum ` `// sum possible for every node ` `// by including them in a segment ` `// with their ancestors ` `int` `dp2[100005]; ` ` `  `// Store the maximum sum ` `// for every node by ` `// including it in a ` `// segment with its successors ` `void` `dfs1(``int` `u, ``int` `par, ` `          ``vector<``int``> g[], ` `          ``int` `weight[]) ` `{ ` ` `  `    ``dp1[u] = weight[u]; ` `    ``for` `(``auto` `c: g[u]) { ` `        ``if` `(c != par) { ` `            ``dfs1(c, u, g, weight); ` `            ``dp1[u] += max(0, dp1); ` `        ``} ` `    ``} ` `} ` ` `  `// Update the maximum sums ` `// for each node by including ` `// them in a sequence with ` `// their ancestors ` `void` `dfs2(``int` `u, ``int` `par, ` `          ``vector<``int``> g[], ` `          ``int` `weight[]) ` `{ ` `    ``// Condition to check, ` `    ``// if current node is not root ` `    ``if` `(par != 0) { ` `        ``int` `maxSumAncestors = dp2[par] ` `                              ``- max(0, dp1[u]); ` `        ``dp2[u] = dp1[u] + max(0, ` `                              ``maxSumAncestors); ` `    ``} ` `    ``for` `(``auto` `c: g[u]) { ` `        ``if` `(c != par) { ` `            ``dfs2(c, u, g, weight); ` `        ``} ` `    ``} ` `} ` ` `  `// Add edges ` `void` `addEdge(``int` `u, ``int` `v, vector<``int``> g[]) ` `{ ` `    ``g[u].push_back(v); ` `    ``g[v].push_back(u); ` `} ` ` `  `// Function to find the maximum ` `// answer for each node ` `void` `maxSumSegments(vector<``int``> g[], ` `                    ``int` `weight[], ` `                    ``int` `n) ` `{ ` ` `  `    ``// Compute the maximum sums ` `    ``// with successors ` `    ``dfs1(1, 0, g, weight); ` ` `  `    ``// Store the computed maximums ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` `        ``dp2[i] = dp1[i]; ` `    ``} ` ` `  `    ``// Update the maximum sums ` `    ``// by including their ` `    ``// ancestors ` `    ``dfs2(1, 0, g, weight); ` `} ` ` `  `// Print the desired result ` `void` `printAns(``int` `n) ` `{ ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` `        ``cout << dp2[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Driver Program ` `int` `main() ` `{ ` ` `  `    ``// Number of nodes ` `    ``int` `n = 6; ` `    ``int` `u, v; ` ` `  `    ``// graph ` `    ``vector<``int``> g[100005]; ` ` `  `    ``// Add edges ` `    ``addEdge(1, 2, g); ` `    ``addEdge(1, 3, g); ` `    ``addEdge(2, 4, g); ` `    ``addEdge(2, 5, g); ` `    ``addEdge(3, 6, g); ` `    ``addEdge(4, 7, g); ` ` `  `    ``// Weight of each node ` `    ``int` `weight[n + 1]; ` `    ``weight[1] = -8; ` `    ``weight[2] = 9; ` `    ``weight[3] = 7; ` `    ``weight[4] = -4; ` `    ``weight[5] = 5; ` `    ``weight[6] = -10; ` `    ``weight[7] = -6; ` ` `  `    ``// Compute the max sum ` `    ``// of segments for each ` `    ``// node ` `    ``maxSumSegments(g, weight, n); ` ` `  `    ``// Print the answer ` `    ``// for every node ` `    ``printAns(n); ` ` `  `    ``return` `0; ` `} `

Output:

```13 14 13 10 14 3
```

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.