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:
- Use the concept of prefix sum and initialize a variable, say res to store the final result.
- Create a dictionary.
- Traverse the array and store all the prefix sum in the dictionary.
- 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.
- Now, there are three possible conditions:
- left > right
- left < right
- left == right
- 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.
- 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 <bits/stdc++.h>
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 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<Integer, Integer> 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<Integer> arr)
{
// To store prefix sums
Map<Integer, Integer> 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<Integer> arr = Arrays.asList(6, 2, 3,
4, 5, 5);
// Function call
maxSum(arr);
}
}
// This code is contributed by offbeat
# 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)
<script>
// js program to implement
// the above approach
// Function to find the maximum sum
function maxweight(s, e, pre){
// Base case
// len of array is 1
if (s == e)
return 0;
// Stores the final result
let ans = 0;
// Traverse the array
for(let i = s; i < e; i++)
{
// Store left prefix sum
if(!pre[i])
pre[i] = 0;
if(!pre[e])
pre[e] = 0;
if(!pre[s-1])
pre[s-1] = 0;
let left = pre[i] - pre[s - 1];
// Store right prefix sum
let 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 final ans
return ans;
}
// Function to print maximum sum
function maxSum(arr)
{
// Dictionary to store prefix sums
let pre = new Map;
pre[-1] = 0;
pre[0] = arr[0];
// Traversing the array
for(let i = 1; i < arr.length; i++)
{
// Add prefix sum of the array
pre[i] = pre[i - 1] + arr[i];
}
document.write( maxweight(0, arr.length - 1, pre));
}
// Driver Code
arr = [ 6, 2, 3, 4, 5, 5 ];
// Function call
maxSum(arr);
</script>
// 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
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 <bits/stdc++.h>
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 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<Integer, Integer> 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<Integer,
Integer> pre = new HashMap<Integer,
Integer>();
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 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)
<script>
// js program to implement
// the above approach
let dp=[];
for(let i = 0;i<100;i++){
dp[i] = [];
for(let j = 0;j<100;j++){
dp[i][j] = 0;
}
}
// Function to find the maximum sum
function maxweight( s, e, 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];
let ans = 0;
// Traverse the array
for(let i = s; i < e; i++)
{
// Store left prefix sum
let left = pre[i] - pre[s - 1];
// Store right prefix sum
let right = pre[e] - pre[i];
// Compare the left and
// right values
if (left < right)
ans = Math.max(
ans, Number(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
function maxSum(arr, n)
{
// Stores prefix sum
let pre = new Map();
pre[-1] = 0;
pre[0] = arr[0];
// Store results of subproblems
for(let i = 0;i<100;i++){
for(let j = 0;j<100;j++){
dp[i][j] = -1;
}
}
// Traversing the array
for(let i = 0; i < n; i++)
// Add prefix sum of array
pre[i] = pre[i - 1] + arr[i];
// Print the answer
document.write(maxweight(0, n - 1, pre));
}
// Driver Code
let arr= [ 6, 2, 3, 4, 5, 5 ];
// Function call
maxSum(arr, 6);
</script>
// 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
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 <bits/stdc++.h>
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
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));
}
}
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))
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 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)
Similar Reads
Maximize the sum of sum of the Array by removing end elements
Given an array arr of size N, the task is to maximize the sum of sum, of the remaining elements in the array, by removing the end elements.Example: Input: arr[] = {2, 3} Output: 3 Explanation: At first we will delete 2, then sum of remaining elements = 3. Then delete 3. Therefore sum of sum = 3 + 0
6 min read
Maximize difference between the Sum of the two halves of the Array after removal of N elements
Given an integer N and array arr[] consisting of 3 * N integers, the task is to find the maximum difference between first half and second half of the array after the removal of exactly N elements from the array. Examples: Input: N = 2, arr[] = {3, 1, 4, 1, 5, 9}Output: 1Explanation:Removal of arr[1]
11 min read
Maximize sum of array elements removed by performing the given operations
Given two arrays arr[] and min[] consisting of N integers and an integer K. For each index i, arr[i] can be reduced to at most min[i]. Consider a variable, say S(initially 0). The task is to find the maximum value of S that can be obtained by performing the following operations: Choose an index i an
8 min read
Maximum sum of Array formed by replacing each element with sum of adjacent elements
Given an array arr[] of size N, the task is to find the maximum sum of the Array formed by replacing each element of the original array with the sum of adjacent elements.Examples: Input: arr = [4, 2, 1, 3] Output: 23 Explanation: Replacing each element of the original array with the sum of adjacent
9 min read
Minimum size of subset of pairs whose sum is at least the remaining array elements
Given two arrays A[] and B[] both consisting of N positive integers, the task is to find the minimum size of the subsets of pair of elements (A[i], B[i]) such that the sum of all the pairs of subsets is at least the sum of remaining array elements A[] which are not including in the subset i.e., (A[0
11 min read
Minimum increments to make all array elements equal with sum same as the given array after exactly one removal
Given an array arr[] of size N and an integer K, the task is to check if all array elements can be made equal by removing an array element and incrementing the value of all other array elements such that the total sum of the array elements remains the same. If found to be true, then print "YES". Oth
7 min read
Length of smallest subarray to be removed to make sum of remaining elements divisible by K
Given an array arr[] of integers and an integer K, the task is to find the length of the smallest subarray that needs to be removed such that the sum of remaining array elements is divisible by K. Removal of the entire array is not allowed. If it is impossible, then print "-1". Examples: Input: arr[
11 min read
Find maximum value of the last element after reducing the array with given operations
Given an array arr[] of N elements, you have to perform the following operation on the given array until the array is reduced to a single elements, Choose two indices i and j such that i != j.Replace arr[i] with arr[i] - arr[j] and remove arr[j] from the array. The task is to maximize and print the
7 min read
Minimum number of elements to be removed such that the sum of the remaining elements is equal to k
Given an array arr[] of integers and an integer k, the task is to find the minimum number of integers that need to be removed from the array such that the sum of the remaining elements is equal to k. If we cannot get the required sum the print -1.Examples: Input: arr[] = {1, 2, 3}, k = 3 Output: 1 E
8 min read
Maximize length of Subarray of 1's after removal of a pair of consecutive Array elements
Given a binary array arr[] consisting of N elements, the task is to find the maximum possible length of a subarray of only 1’s, after deleting a single pair of consecutive array elements. If no such subarray exists, print -1. Examples: Input: arr[] = {1, 1, 1, 0, 0, 1} Output: 4 Explanation: Removal
15+ min read