# Maximize sum of remaining elements after every removal of the array half with greater sum

Last Updated : 25 Apr, 2023

Given an array arr[] consisting of N integers, the task is to maximize the resultant sum obtained after adding remaining elements after every removal of the array half with maximum sum.

Array can be divided into two non-empty halves left[] and right[] where left[] contains the elements from the indices [0, N/2) and right[] contains the elements from the indices [N/2, N)

Examples:

Input: arr[] = {6, 2, 3, 4, 5, 5}
Output: 18
Explanation:
The given array is arr[] = {6, 2, 3, 4, 5, 5}
Step 1:
Sum of left half = 6 + 2 + 3 = 11
Sum of right half = 4 + 5 + 5 = 12
Resultant sum S = 11.
Step 2:
Modified array is arr[] = {6, 2, 3}
Sum of left half = 6
Sum of right half = 2 + 3 = 5
Resultant sum S = 11 + 5 = 16
Step 3:
Modified array is arr[] = {2, 3}
Sum of left half = 2
Sum of right half = 3
Resultant sum S = 16 + 2 = 18.
Therefore, the resultant sum is 18.

Input: arr[] = {4}
Output: 0

Naive Approach: The simplest approach to solve the problem is to use recursion. Below are the steps:

1. Use the concept of prefix sum and initialize a variable, say res to store the final result.
2. Create a dictionary.
3. Traverse the array and store all the prefix sum in the dictionary.
4. Now, iterate over the range [0, N] and store the prefix sum of left and right halves of the array as left and right respectively.
5. Now, there are three possible conditions:
• left > right
• left < right
• left == right
6. For all the above conditions, ignore the maximum sum and add the minimum among left and right sum to the resultant sum and continue the recursive calls.
7. After all the recursive call ends, print the maximum value of the resultant sum.

Below is the implementation of the above approach:

## C++14

 `// C++14 program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the maximum sum` `int` `maxweight(``int` `s, ``int` `e,` `  ``unordered_map<``int``, ``int``>& pre)` `{` `    `  `    ``// Base case` `    ``// len of array is 1` `    ``if` `(s == e)` `        ``return` `0;`   `    ``// Stores the final result` `    ``int` `ans = 0;`   `    ``// Traverse the array` `    ``for``(``int` `i = s; i < e; i++)` `    ``{` `        `  `        ``// Store left prefix sum` `        ``int` `left = pre[i] - pre[s - 1];`   `        ``// Store right prefix sum` `        ``int` `right = pre[e] - pre[i];`   `        ``// Compare the left and right` `        ``if` `(left < right)` `            ``ans = max(ans, left + ` `                      ``maxweight(s, i, pre));`   `        ``// If both are equal apply` `        ``// the optimal method` `        ``if` `(left == right)` `        ``{` `            ``// Update with minimum` `            ``ans = max({ans, left +` `                       ``maxweight(s, i, pre),` `                             ``right +` `                       ``maxweight(i + 1, e, pre)});` `        ``}`   `        ``if` `(left > right)` `            ``ans = max(ans, right + ` `                     ``maxweight(i + 1, e, pre));` `    ``}     `   `    ``// Return the final ans` `    ``return` `ans;` `}`   `// Function to print maximum sum` `void` `maxSum(vector<``int``> arr)` `{` `    `  `    ``// Dictionary to store prefix sums` `    ``unordered_map<``int``, ``int``> pre;` `    ``pre[-1] = 0;` `    ``pre[0] = arr[0];`   `    ``// Traversing the array` `    ``for``(``int` `i = 1; i < arr.size(); i++)` `    ``{ ` `        `  `        ``// Add prefix sum of the array` `        ``pre[i] = pre[i - 1] + arr[i];` `    ``}` `    ``cout << maxweight(0, arr.size() - 1, pre);` `}`   `// Driver Code` `int` `main()` `{` `    ``vector<``int``> arr = { 6, 2, 3, 4, 5, 5 };` `    `  `    ``// Function call` `    ``maxSum(arr);` `    `  `    ``return` `0;` `}`   `// This code is contributed by mohit kumar 29`

## Java

 `// Java program to implement ` `// the above approach ` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to find the maximum sum` `static` `int` `maxweight(``int` `s, ``int` `e,` `                     ``Map pre)` `{` `    `  `    ``// Base case` `    ``// len of array is 1` `    ``if` `(s == e)` `        ``return` `0``;`   `    ``// Stores the final result` `    ``int` `ans = ``0``;`   `    ``// Traverse the array` `    ``for``(``int` `i = s; i < e; i++)` `    ``{` `        `  `        ``// Store left prefix sum` `        ``int` `left = pre.get(i) - pre.get(s - ``1``);`   `        ``// Store right prefix sum` `        ``int` `right = pre.get(e) - pre.get(i);`   `        ``// Compare the left and right` `        ``if` `(left < right)` `            ``ans = Math.max(ans, left + ` `                           ``maxweight(s, i, pre));`   `        ``// If both are equal apply` `        ``// the optimal method` `        ``if` `(left == right)` `        ``{` `            `  `            ``// Update with minimum` `            ``ans = Math.max(ans, Math.max(left +` `                           ``maxweight(s, i, pre),` `                           ``right + maxweight(i + ``1``,` `                                             ``e, pre)));` `        ``}`   `        ``if` `(left > right)` `            ``ans = Math.max(ans, right + ` `                           ``maxweight(i + ``1``, e, pre));` `    ``}     ` `    `  `    ``// Return the final ans` `    ``return` `ans;` `}`   `// Function to print maximum sum` `static` `void` `maxSum(List arr)` `{` `    `  `    ``// To store prefix sums` `    ``Map pre = ``new` `HashMap<>();` `    ``pre.put(-``1``, ``0``);` `    ``pre.put(``0``, arr.get(``0``)); `   `    ``// Traversing the array` `    ``for``(``int` `i = ``1``; i < arr.size(); i++)` `    ``{ ` `        `  `        ``// Add prefix sum of the array` `        ``pre.put(i, pre.getOrDefault(i - ``1``, ``0``) + ` `                   ``arr.get(i));` `    ``}` `    ``System.out.println(maxweight(``0``, ` `                ``arr.size() - ``1``, pre));` `}`   `// Driver code` `public` `static` `void` `main (String[] args)` `{` `    ``List arr = Arrays.asList(``6``, ``2``, ``3``, ` `                                      ``4``, ``5``, ``5``);` `    `  `    ``// Function call` `    ``maxSum(arr);` `}` `}`   `// This code is contributed by offbeat`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the maximum sum` `def` `maxweight(s, e, pre):`   `    ``# Base case ` `    ``# len of array is 1` `    ``if` `s ``=``=` `e:` `        ``return` `0`   `    ``# Stores the final result` `    ``ans ``=` `0`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(s, e):`   `        ``# Store left prefix sum` `        ``left ``=` `pre[i] ``-` `pre[s ``-` `1``]`   `        ``# Store right prefix sum` `        ``right ``=` `pre[e] ``-` `pre[i]`   `        ``# Compare the left and right` `        ``if` `left < right:` `            ``ans ``=` `max``(ans, left \` `            ``+` `maxweight(s, i, pre))`   `        ``# If both are equal apply` `        ``# the optimal method` `        ``if` `left ``=``=` `right:`   `            ``# Update with minimum ` `            ``ans ``=` `max``(ans, left \` `                  ``+` `maxweight(s, i, pre), ` `                    ``right \` `                  ``+` `maxweight(i ``+` `1``, e, pre))`   `        ``if` `left > right:` `            ``ans ``=` `max``(ans, right \` `                  ``+` `maxweight(i ``+` `1``, e, pre))`   `    ``# Return the final ans` `    ``return` `ans`   `# Function to print maximum sum` `def` `maxSum(arr):`   `    ``# Dictionary to store prefix sums` `    ``pre ``=` `{``-``1``: ``0``, ``0``: arr[``0``]}`   `    ``# Traversing the array` `    ``for` `i ``in` `range``(``1``, ``len``(arr)):`   `        ``# Add prefix sum of the array` `        ``pre[i] ``=` `pre[i ``-` `1``] ``+` `arr[i]` `    `  `    ``print``(maxweight(``0``, ``len``(arr) ``-` `1``, pre))`   `# Drivers Code`   `arr ``=` `[``6``, ``2``, ``3``, ``4``, ``5``, ``5``]`   `# Function Call` `maxSum(arr)`

## Javascript

 ``

## C#

 `// C# program to implement ` `// the above approach ` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{` `    `  `// Function to find the maximum sum` `static` `int` `maxweight(``int` `s, ``int` `e,` `                     ``Dictionary<``int``, ` `                     ``int``> pre)` `{` `  ``// Base case` `  ``// len of array is 1` `  ``if` `(s == e)` `    ``return` `0;`   `  ``// Stores the ` `  ``// readonly result` `  ``int` `ans = 0;`   `  ``// Traverse the array` `  ``for``(``int` `i = s; i < e; i++)` `  ``{` `    ``// Store left prefix sum` `    ``int` `left = pre[i] - pre[s - 1];`   `    ``// Store right prefix sum` `    ``int` `right = pre[e] - pre[i];`   `    ``// Compare the left and right` `    ``if` `(left < right)` `      ``ans = Math.Max(ans, left + ` `            ``maxweight(s, i, pre));`   `    ``// If both are equal apply` `    ``// the optimal method` `    ``if` `(left == right)` `    ``{` `      ``// Update with minimum` `      ``ans = Math.Max(ans, Math.Max(left +` `                          ``maxweight(s, i, pre),` `                          ``right + maxweight(i + 1,` `                                            ``e, pre)));` `    ``}`   `    ``if` `(left > right)` `      ``ans = Math.Max(ans, right + ` `            ``maxweight(i + 1, e, pre));` `  ``}     `   `  ``// Return the readonly ans` `  ``return` `ans;` `}`   `// Function to print maximum sum` `static` `void` `maxSum(List<``int``> arr)` `{` `    `  `  ``// To store prefix sums` `  ``Dictionary<``int``, ` `             ``int``> pre = ``new` `Dictionary<``int``, ` `                                       ``int``>();` `  ``pre.Add(-1, 0);` `  ``pre.Add(0, arr[0]); `   `  ``// Traversing the array` `  ``for``(``int` `i = 1; i < arr.Count; i++)` `  ``{ ` `    ``// Add prefix sum of the array` `    ``if``(pre[i - 1] != 0)` `      ``pre.Add(i, pre[i - 1] + arr[i]);` `    ``else` `      ``pre.Add(i, arr[i]);` `  ``}` `  ``Console.WriteLine(maxweight(0, ` `                    ``arr.Count - 1, pre));` `}`   `// Driver code` `public` `static` `void` `Main(String[] args)` `{` `  ``List<``int``> arr = ``new` `List<``int``>();` `  ``arr.Add(6);` `  ``arr.Add(2);` `  ``arr.Add(3);` `  ``arr.Add(4);` `  ``arr.Add(5);` `  ``arr.Add(5);`   `  ``// Function call` `  ``maxSum(arr);` `}` `}`   `// This code is contributed by gauravrajput1`

Output:

`18`

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

Efficient Approach: To optimize the above approach, the idea is to observe that there are a number of repeated overlapping subproblems
Therefore, for optimization, use Dynamic Programming. The idea is to use a dictionary and keep track of the result values so that when they are required in further computations it can be accessed without calculating them again.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `int` `dp[100][100];`   `// Function to find the maximum sum` `int` `maxweight(``int` `s, ``int` `e, ` `          ``map<``int``, ``int``> pre)` `{` `    `  `    ``// Base Case` `    ``if` `(s == e)` `        ``return` `0;`   `    ``// Create a key to map` `    ``// the values`   `    ``// Check if (mapped key is` `    ``// found in the dictionary` `    ``if` `(dp[s][e] != -1)` `        ``return` `dp[s][e];`   `    ``int` `ans = 0;`   `    ``// Traverse the array` `    ``for``(``int` `i = s; i < e; i++)` `    ``{` `        `  `        ``// Store left prefix sum` `        ``int` `left = pre[i] - pre[s - 1];`   `        ``// Store right prefix sum` `        ``int` `right = pre[e] - pre[i];`   `        ``// Compare the left and` `        ``// right values` `        ``if` `(left < right)` `            ``ans = max(` `                ``ans, (``int``)(left + ` `                           ``maxweight(s, i, pre)));`   `        ``if` `(left == right)` `            ``ans = max(` `                ``ans, max(left + maxweight(s, i,` `                                          ``pre),` `                         ``right + maxweight(i + 1, ` `                                           ``e, pre)));`   `        ``if` `(left > right)` `            ``ans = max(` `                ``ans, right + maxweight(i + 1, e, pre));`   `        ``// Store the value in dp array` `        ``dp[s][e] = ans;` `    ``}`   `    ``// Return the final answer` `    ``return` `dp[s][e];` `}`   `// Function to print maximum sum` `void` `maxSum(``int` `arr[], ``int` `n)` `{` `    `  `    ``// Stores prefix sum` `    ``map<``int``, ``int``> pre;` `    ``pre[-1] = 0;` `    ``pre[0] = arr[0];`   `    ``// Store results of subproblems` `    ``memset``(dp, -1, ``sizeof` `dp);`   `    ``// Traversing the array` `    ``for``(``int` `i = 0; i < n; i++)`   `        ``// Add prefix sum of array` `        ``pre[i] = pre[i - 1] + arr[i];`   `    ``// Print the answer` `    ``cout << (maxweight(0, n - 1, pre));` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 6, 2, 3, 4, 5, 5 };`   `    ``// Function call` `    ``maxSum(arr, 6);` `}`   `// This code is contributed by grand_master`

## Java

 `// Java program to implement` `// the above approach` `import` `java.util.*;`   `class` `solution{` `   `  `static` `int``[][] dp = ``new` `int``[``100``][``100``]; `   `// Function to find the maximum sum` `static` `int` `maxweight(``int` `s, ``int` `e, ` `                     ``HashMap pre)` `{` `    `  `    ``// Base Case` `    ``if` `(s == e)` `        ``return` `0``;`   `    ``// Create a key to map` `    ``// the values`   `    ``// Check if (mapped key is` `    ``// found in the dictionary` `    ``if` `(dp[s][e] != -``1``)` `        ``return` `dp[s][e];`   `    ``int` `ans = ``0``;`   `    ``// Traverse the array` `    ``for``(``int` `i = s; i < e; i++)` `    ``{` `        `  `        ``// Store left prefix sum` `        ``int` `left = pre.get(i) - ` `                   ``pre.get(s - ``1``);`   `        ``// Store right prefix sum` `        ``int` `right = pre.get(e) - ` `                    ``pre.get(i);`   `        ``// Compare the left and` `        ``// right values` `        ``if` `(left < right)` `            ``ans = Math.max(ans, (``int``)(left + ` `                           ``maxweight(s, i, pre)));`   `        ``if` `(left == right)` `            ``ans = Math.max(ans, ` `                           ``Math.max(left + maxweight(s, i,` `                                                     ``pre),` `                                    ``right + maxweight(i + ``1``, ` `                                                      ``e, pre)));`   `        ``if` `(left > right)` `            ``ans = Math.max(ans, right + maxweight(i + ``1``,` `                                                  ``e, pre));`   `        ``// Store the value in dp array` `        ``dp[s][e] = ans;` `    ``}` `    `  `    ``// Return the final answer` `    ``return` `dp[s][e];` `}`   `// Function to print maximum sum` `static` `void` `maxSum(``int` `arr[], ``int` `n)` `{` `    `  `    ``// Stores prefix sum` `    ``HashMap pre = ``new` `HashMap();` `    ``pre.put(-``1``, ``0``);` `    ``pre.put(``0``, arr[``0``]);`   `    ``// Store results of subproblems` `    ``for``(``int` `i = ``0``; i < ``100``; i++)` `    ``{` `        ``for``(``int` `j = ``0``; j < ``100``; j++)` `          ``dp[i][j] = -``1``;` `    ``}`   `    ``// Traversing the array` `    ``for``(``int` `i = ``0``; i < n; i++)`   `        ``// Add prefix sum of array` `        ``pre.put(i, pre.get(i - ``1``) + arr[i]);`   `    ``// Print the answer` `    ``System.out.print((maxweight(``0``, n - ``1``, pre)));` `}`   `// Driver Code` `public` `static` `void` `main(String args[])` `{` `    ``int` `[]arr = { ``6``, ``2``, ``3``, ``4``, ``5``, ``5` `};` `    `  `    ``// Function call` `    ``maxSum(arr, ``6``);` `}` `}`   `// This code is contributed by Surendra_Gangwar`

## Python3

 `# Python3 program to implement` `# the above approach`   `# Function to find the maximum sum` `def` `maxweight(s, e, pre, dp):`   `    ``# Base Case  ` `    ``if` `s ``=``=` `e:` `        ``return` `0`   `    ``# Create a key to map ` `    ``# the values` `    ``key ``=` `(s, e)` `   `  `    ``# Check if mapped key is ` `    ``# found in the dictionary ` `    ``if` `key ``in` `dp:` `        ``return` `dp[key]`   `    ``ans ``=` `0`   `    ``# Traverse the array` `    ``for` `i ``in` `range``(s, e):`   `         ``# Store left prefix sum` `        ``left ``=` `pre[i] ``-` `pre[s``-``1``]` ` `  `        ``# Store right prefix sum` `        ``right ``=` `pre[e] ``-` `pre[i]`   `        ``# Compare the left and` `        ``# right values` `        ``if` `left < right:` `            ``ans ``=` `max``(ans, left \` `                ``+` `maxweight(s, i, pre, dp))`   `        ``if` `left ``=``=` `right:`   `            ``# Update with minimum` `            ``ans ``=` `max``(ans, left \` `                  ``+` `maxweight(s, i, pre, dp), ` `                  ``right \` `                  ``+` `maxweight(i ``+` `1``, e, pre, dp))`   `        ``if` `left > right:` `           ``ans ``=` `max``(ans, right \` `                 ``+` `maxweight(i ``+` `1``, e, pre, dp))`   `        ``# Store the value in dp array` `        ``dp[key] ``=` `ans`   `    ``# Return the final answer` `    ``return` `dp[key]`   `# Function to print maximum sum` `def` `maxSum(arr):`   `    ``# Stores prefix sum` `    ``pre ``=` `{``-``1``: ``0``, ``0``: arr[``0``]}`   `    ``# Store results of subproblems` `    ``dp ``=` `{}`   `    ``# Traversing the array` `    ``for` `i ``in` `range``(``1``, ``len``(arr)):` `        `  `        ``# Add prefix sum of array` `        ``pre[i] ``=` `pre[i ``-` `1``] ``+` `arr[i]`   `    ``# Print the answer` `    ``print``(maxweight(``0``, ``len``(arr) ``-` `1``, pre, dp))`   `# Driver Code`   `arr ``=` `[``6``, ``2``, ``3``, ``4``, ``5``, ``5``]`   `# Function Call` `maxSum(arr)`

## Javascript

 ``

## C#

 `// C# program to implement` `// the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` `   `  `static` `int``[,] dp = ``new` `int``[100, 100]; `   `// Function to find the maximum sum` `static` `int` `maxweight(``int` `s, ``int` `e, ` `          ``Dictionary<``int``, ``int``> pre)` `{` `    `  `    ``// Base Case` `    ``if` `(s == e)` `        ``return` `0;`   `    ``// Create a key to map` `    ``// the values`   `    ``// Check if (mapped key is` `    ``// found in the dictionary` `    ``if` `(dp[s, e] != -1)` `        ``return` `dp[s, e];`   `    ``int` `ans = 0;`   `    ``// Traverse the array` `    ``for``(``int` `i = s; i < e; i++)` `    ``{` `        `  `        ``// Store left prefix sum` `        ``int` `left = pre[i] - ` `                   ``pre[s - 1];`   `        ``// Store right prefix sum` `        ``int` `right = pre[e] - ` `                    ``pre[i];`   `        ``// Compare the left and` `        ``// right values` `        ``if` `(left < right)` `            ``ans = Math.Max(ans, (``int``)(left + ` `                           ``maxweight(s, i, pre)));`   `        ``if` `(left == right)` `            ``ans = Math.Max(ans, ` `                           ``Math.Max(left + maxweight(s, i,` `                                                     ``pre),` `                                   ``right + maxweight(i + 1, ` `                                                     ``e, pre)));`   `        ``if` `(left > right)` `            ``ans = Math.Max(ans, right + maxweight(i + 1,` `                                                  ``e, pre));`   `        ``// Store the value in dp array` `        ``dp[s, e] = ans;` `    ``}` `    `  `    ``// Return the readonly answer` `    ``return` `dp[s, e];` `}`   `// Function to print maximum sum` `static` `void` `maxSum(``int` `[]arr, ``int` `n)` `{` `    `  `    ``// Stores prefix sum` `    ``Dictionary<``int``,` `               ``int``> pre = ``new` `Dictionary<``int``,` `                                         ``int``>();` `    ``pre.Add(-1, 0);` `    ``pre.Add(0, arr[0]);`   `    ``// Store results of subproblems` `    ``for``(``int` `i = 0; i < 100; i++)` `    ``{` `        ``for``(``int` `j = 0; j < 100; j++)` `          ``dp[i, j] = -1;` `    ``}`   `    ``// Traversing the array` `    ``for``(``int` `i = 1; i < n; i++)`   `        ``// Add prefix sum of array` `        ``pre.Add(i, pre[i - 1] + arr[i]);`   `    ``// Print the answer` `    ``Console.Write((maxweight(0, n - 1, pre)));` `}`   `// Driver Code` `public` `static` `void` `Main(String []args)` `{` `    ``int` `[]arr = { 6, 2, 3, 4, 5, 5 };` `    `  `    ``// Function call` `    ``maxSum(arr, 6);` `}` `}`   `// This code is contributed by Amit Katiyar`

Output:

`18`

Time Complexity: O(N3
Auxiliary Space: O(N2)

Efficient approach : Using DP Tabulation method ( Iterative approach )

The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.

Steps to solve this problem :

• Create a table DP to store the solution of the subproblems.
• Initialize the table with base cases.
• Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP.
• Return the final solution stored in dp[0][n-1].

Implementation :

## C++

 `// C++ code for above approach`   `#include ` `using` `namespace` `std;`   `int` `maxSum(``int` `arr[], ``int` `n)` `{` `    ``// Create a prefix sum array` `    ``int` `pre[n+1];` `    ``pre[0] = 0;` `    ``for` `(``int` `i = 1; i <= n; i++)` `        ``pre[i] = pre[i-1] + arr[i-1];` `    `  `    ``// Create a 2D dp table` `    ``int` `dp[n][n];` `    `  `    ``// Fill the diagonal elements with 0` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``dp[i][i] = 0;` `    `  `    ``// Fill the remaining elements` `    ``for` `(``int` `len = 2; len <= n; len++) {` `        ``for` `(``int` `i = 0; i <= n-len; i++) {` `            ``int` `j = i + len - 1;` `            ``dp[i][j] = INT_MIN;` `          `  `              ``// iterate over subproblems and get ` `              ``// the current value from previous computation` `            ``for` `(``int` `k = i; k < j; k++) {` `                ``int` `left_sum = pre[k+1] - pre[i];` `                ``int` `right_sum = pre[j+1] - pre[k+1];` `              `  `                  ``// update current value with ` `                  ``// respect to different cases` `                ``if` `(left_sum < right_sum)` `                    ``dp[i][j] = max(dp[i][j], left_sum + dp[i][k]);` `                ``else` `if` `(left_sum > right_sum)` `                    ``dp[i][j] = max(dp[i][j], right_sum + dp[k+1][j]);` `                ``else` `                    ``dp[i][j] = max(dp[i][j], max(left_sum + ` `                                                 ``dp[i][k], right_sum + dp[k+1][j]));` `            ``}` `        ``}` `    ``}` `    `  `    ``// Return the maximum sum` `    ``return` `dp[0][n-1];` `}`   `int` `main()` `{` `    ``int` `arr[] = {6, 2, 3, 4, 5, 5};` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);` `      ``// function call` `    ``cout << maxSum(arr, n) << endl;` `    ``return` `0;` `}` `// this code is contributed by bhardwajji`

## Java

 `import` `java.util.*;`   `public` `class` `Main {` `    ``public` `static` `int` `maxSum(``int``[] arr, ``int` `n) {` `        ``// Create a prefix sum array` `        ``int``[] pre = ``new` `int``[n+``1``];` `        ``pre[``0``] = ``0``;` `        ``for` `(``int` `i = ``1``; i <= n; i++)` `            ``pre[i] = pre[i-``1``] + arr[i-``1``];` `        `  `        ``// Create a 2D dp table` `        ``int``[][] dp = ``new` `int``[n][n];` `        `  `        ``// Fill the diagonal elements with 0` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``dp[i][i] = ``0``;` `        `  `        ``// Fill the remaining elements` `        ``for` `(``int` `len = ``2``; len <= n; len++) {` `            ``for` `(``int` `i = ``0``; i <= n-len; i++) {` `                ``int` `j = i + len - ``1``;` `                ``dp[i][j] = Integer.MIN_VALUE;` `              `  `                  ``// iterate over subproblems and get ` `                  ``// the current value from previous computation` `                ``for` `(``int` `k = i; k < j; k++) {` `                    ``int` `left_sum = pre[k+``1``] - pre[i];` `                    ``int` `right_sum = pre[j+``1``] - pre[k+``1``];` `                  `  `                      ``// update current value with ` `                      ``// respect to different cases` `                    ``if` `(left_sum < right_sum)` `                        ``dp[i][j] = Math.max(dp[i][j], left_sum + dp[i][k]);` `                    ``else` `if` `(left_sum > right_sum)` `                        ``dp[i][j] = Math.max(dp[i][j], right_sum + dp[k+``1``][j]);` `                    ``else` `                        ``dp[i][j] = Math.max(dp[i][j], Math.max(left_sum + ` `                                                     ``dp[i][k], right_sum + dp[k+``1``][j]));` `                ``}` `            ``}` `        ``}` `        `  `        ``// Return the maximum sum` `        ``return` `dp[``0``][n-``1``];` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``6``, ``2``, ``3``, ``4``, ``5``, ``5``};` `        ``int` `n = arr.length;` `          ``// function call` `        ``System.out.println(maxSum(arr, n));` `    ``}` `}`

## Python3

 `def` `maxSum(arr, n):` `    ``# Create a prefix sum array` `    ``pre ``=` `[``0``] ``*` `(n``+``1``)` `    ``for` `i ``in` `range``(``1``, n``+``1``):` `        ``pre[i] ``=` `pre[i``-``1``] ``+` `arr[i``-``1``]`   `    ``# Create a 2D dp table` `    ``dp ``=` `[[``0` `for` `j ``in` `range``(n)] ``for` `i ``in` `range``(n)]`   `    ``# Fill the diagonal elements with 0` `    ``for` `i ``in` `range``(n):` `        ``dp[i][i] ``=` `0`   `    ``# Fill the remaining elements` `    ``for` `length ``in` `range``(``2``, n``+``1``):` `        ``for` `i ``in` `range``(n``-``length``+``1``):` `            ``j ``=` `i ``+` `length ``-` `1` `            ``dp[i][j] ``=` `float``(``'-inf'``)`   `            ``# iterate over subproblems and get ` `            ``# the current value from previous computation` `            ``for` `k ``in` `range``(i, j):` `                ``left_sum ``=` `pre[k``+``1``] ``-` `pre[i]` `                ``right_sum ``=` `pre[j``+``1``] ``-` `pre[k``+``1``]`   `                ``# update current value with ` `                ``# respect to different cases` `                ``if` `left_sum < right_sum:` `                    ``dp[i][j] ``=` `max``(dp[i][j], left_sum ``+` `dp[i][k])` `                ``elif` `left_sum > right_sum:` `                    ``dp[i][j] ``=` `max``(dp[i][j], right_sum ``+` `dp[k``+``1``][j])` `                ``else``:` `                    ``dp[i][j] ``=` `max``(dp[i][j], ``max``(left_sum ``+` `dp[i][k], right_sum ``+` `dp[k``+``1``][j]))`   `    ``# Return the maximum sum` `    ``return` `dp[``0``][n``-``1``]`   `# Driver code` `arr ``=` `[``6``, ``2``, ``3``, ``4``, ``5``, ``5``]` `n ``=` `len``(arr)`   `# Function call` `print``(maxSum(arr, n))`

## C#

 `using` `System;`   `public` `class` `MaxSumSubsequence` `{` `    ``public` `static` `int` `MaxSum(``int``[] arr, ``int` `n)` `    ``{` `        ``// Create a prefix sum array` `        ``int``[] pre = ``new` `int``[n+1];` `        ``pre[0] = 0;` `        ``for` `(``int` `i = 1; i <= n; i++)` `            ``pre[i] = pre[i-1] + arr[i-1];`   `        ``// Create a 2D dp table` `        ``int``[,] dp = ``new` `int``[n,n];`   `        ``// Fill the diagonal elements with 0` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``dp[i,i] = 0;`   `        ``// Fill the remaining elements` `        ``for` `(``int` `len = 2; len <= n; len++) {` `            ``for` `(``int` `i = 0; i <= n-len; i++) {` `                ``int` `j = i + len - 1;` `                ``dp[i,j] = ``int``.MinValue;`   `                ``// iterate over subproblems and get ` `                ``// the current value from previous computation` `                ``for` `(``int` `k = i; k < j; k++) {` `                    ``int` `left_sum = pre[k+1] - pre[i];` `                    ``int` `right_sum = pre[j+1] - pre[k+1];`   `                    ``// update current value with ` `                    ``// respect to different cases` `                    ``if` `(left_sum < right_sum)` `                        ``dp[i,j] = Math.Max(dp[i,j], left_sum + dp[i,k]);` `                    ``else` `if` `(left_sum > right_sum)` `                        ``dp[i,j] = Math.Max(dp[i,j], right_sum + dp[k+1,j]);` `                    ``else` `                        ``dp[i,j] = Math.Max(dp[i,j], Math.Max(left_sum + dp[i,k], right_sum + dp[k+1,j]));` `                ``}` `            ``}` `        ``}`   `        ``// Return the maximum sum` `        ``return` `dp[0,n-1];` `    ``}`   `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] arr = {6, 2, 3, 4, 5, 5};` `        ``int` `n = arr.Length;` `        ``// function call` `        ``Console.WriteLine(MaxSum(arr, n));` `    ``}` `}`

## Javascript

 `// Javascript code for above approach` `function` `maxSum(arr, n) {` `    ``// Create a prefix sum array` `    ``let pre = ``new` `Array(n + 1);` `    ``pre[0] = 0;` `    ``for` `(let i = 1; i <= n; i++) {` `        ``pre[i] = pre[i - 1] + arr[i - 1];` `    ``}`   `    ``// Create a 2D dp table` `    ``let dp = ``new` `Array(n);` `    ``for` `(let i = 0; i < n; i++) {` `        ``dp[i] = ``new` `Array(n);` `    ``}`   `    ``// Fill the diagonal elements with 0` `    ``for` `(let i = 0; i < n; i++) {` `        ``dp[i][i] = 0;` `    ``}`   `    ``// Fill the remaining elements` `    ``for` `(let len = 2; len <= n; len++) {` `        ``for` `(let i = 0; i <= n - len; i++) {` `            ``let j = i + len - 1;` `            ``dp[i][j] = Number.MIN_SAFE_INTEGER;`   `            ``// iterate over subproblems and get ` `            ``// the current value from previous computation` `            ``for` `(let k = i; k < j; k++) {` `                ``let left_sum = pre[k + 1] - pre[i];` `                ``let right_sum = pre[j + 1] - pre[k + 1];`   `                ``// update current value with ` `                ``// respect to different cases` `                ``if` `(left_sum < right_sum) {` `                    ``dp[i][j] = Math.max(dp[i][j], left_sum + dp[i][k]);` `                ``} ``else` `if` `(left_sum > right_sum) {` `                    ``dp[i][j] = Math.max(dp[i][j], right_sum + dp[k + 1][j]);` `                ``} ``else` `{` `                    ``dp[i][j] = Math.max(dp[i][j], Math.max(left_sum + dp[i][k], right_sum + dp[k + 1][j]));` `                ``}` `            ``}` `        ``}` `    ``}`   `    ``// Return the maximum sum` `    ``return` `dp[0][n - 1];` `}`   `let arr = [6, 2, 3, 4, 5, 5];` `let n = arr.length;` `console.log(maxSum(arr, n));`

Output

`18`

Time Complexity: O(N3
Auxiliary Space: O(N2)

Previous
Next