# Maximize sum of an Array by flipping sign of all elements of a single subarray

Given an array arr[] of N integers, the task is to find the maximum sum of the array that can be obtained by flipping signs of any subarray of the given array at most once.

Examples:

Input: arr[] = {-2, 3, -1, -4, -2}
Output: 8
Explanation:
Flipping the signs of subarray {-1, -4, -2} modifies the array to {-2, 3, 1, 4, 2}. Therefore, the sum of the array = -2 + 3 + 1 + 4 + 2 = 8, which is the maximum possible.

Input: arr[] = {1, 2, -10, 2, -20}
Output: 31
Explanation:
Flipping the signs of subarray {-10, 2, -20} modifies the array to {1, 2, 10, -2, 20}. Therefore, the sum of the array = 1 + 2 + 10 – 2 + 20 = 31, which is the maximum possible.

Naive Approach: The simplest approach is to calculate the total sum of the array and then generate all possible subarrays. Now, for each subarray {A[i], … A[j]}, subtract its sum, sum(A[i], …, A[j]), from the total sum and flip the signs of the subarray elements. After flipping the subarray, add the sum of the flipped subarray, i.e. (-1 * sum(A[i], …, A[j])), to the total sum. Below are the steps:

1. Find the total sum of the original array (say total_sum) and store it.
2. Now, for all possible subarrays find the maximum of total_sum – 2 * sum(i, j).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum sum``// after flipping a subarray``int` `maxSumFlip(``int` `a[], ``int` `n)``{` `    ``// Stores the total sum of array``    ``int` `total_sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``total_sum += a[i];` `    ``// Initialize the maximum sum``    ``int` `max_sum = INT_MIN;` `    ``// Iterate over all possible subarrays``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``// Initialize sum of the subarray``        ``// before flipping sign``        ``int` `sum = 0;` `        ``for` `(``int` `j = i; j < n; j++) ``        ``{``            ``// Calculate the sum of``            ``// original subarray``            ``sum += a[j];` `            ``// Subtract the original``            ``// subarray sum and add``            ``// the flipped subarray``            ``// sum to the total sum``            ``max_sum = max(max_sum, total_sum - 2 * sum);``        ``}``    ``}` `    ``// Return the max_sum``    ``return` `max(max_sum, total_sum);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { -2, 3, -1, -4, -2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);` `    ``cout << maxSumFlip(arr, N);``}` `// This code is contributed by sanjoy_62`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `public` `class` `GFG ``{``    ``// Function to find the maximum sum``    ``// after flipping a subarray``    ``public` `static` `int` `maxSumFlip(``int` `a[], ``int` `n)``    ``{``        ``// Stores the total sum of array``        ``int` `total_sum = ``0``;``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``total_sum += a[i];` `        ``// Initialize the maximum sum``        ``int` `max_sum = Integer.MIN_VALUE;` `        ``// Iterate over all possible subarrays``        ``for` `(``int` `i = ``0``; i < n; i++) ``        ``{``            ``// Initialize sum of the subarray``            ``// before flipping sign``            ``int` `sum = ``0``;` `            ``for` `(``int` `j = i; j < n; j++) ``            ``{``                ``// Calculate the sum of``                ``// original subarray``                ``sum += a[j];` `                ``// Subtract the original``                ``// subarray sum and add``                ``// the flipped subarray``                ``// sum to the total sum``                ``max_sum = Math.max(max_sum,``                                   ``total_sum - ``2` `* sum);``            ``}``        ``}` `        ``// Return the max_sum``        ``return` `Math.max(max_sum, total_sum);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = { -``2``, ``3``, -``1``, -``4``, -``2` `};``        ``int` `N = arr.length;``      ` `        ``// Function call``        ``System.out.println(maxSumFlip(arr, N));``    ``}``}`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to find the maximum sum``# after flipping a subarray`  `def` `maxSumFlip(a, n):` `    ``# Stores the total sum of array``    ``total_sum ``=` `0``    ``for` `i ``in` `range``(n):``        ``total_sum ``+``=` `a[i]` `    ``# Initialize the maximum sum``    ``max_sum ``=` `-``sys.maxsize ``-` `1` `    ``# Iterate over all possible subarrays``    ``for` `i ``in` `range``(n):` `        ``# Initialize sum of the subarray``        ``# before flipping sign``        ``sum` `=` `0` `        ``for` `j ``in` `range``(i, n):` `            ``# Calculate the sum of``            ``# original subarray``            ``sum` `+``=` `a[j]` `            ``# Subtract the original``            ``# subarray sum and add``            ``# the flipped subarray``            ``# sum to the total sum``            ``max_sum ``=` `max``(max_sum,``                          ``total_sum ``-` `2` `*` `sum``)` `    ``# Return the max_sum``    ``return` `max``(max_sum, total_sum)`  `# Driver Code``arr ``=` `[``-``2``, ``3``, ``-``1``, ``-``4``, ``-``2``]``N ``=` `len``(arr)` `print``(maxSumFlip(arr, N))` `# This code is contributed by sanjoy_62`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG {` `    ``// Function to find the maximum sum``    ``// after flipping a subarray``    ``public` `static` `int` `maxSumFlip(``int``[] a, ``int` `n)``    ``{` `        ``// Stores the total sum of array``        ``int` `total_sum = 0;``        ``for` `(``int` `i = 0; i < n; i++)``            ``total_sum += a[i];` `        ``// Initialize the maximum sum``        ``int` `max_sum = ``int``.MinValue;` `        ``// Iterate over all possible subarrays``        ``for` `(``int` `i = 0; i < n; i++) ``        ``{``            ``// Initialize sum of the subarray``            ``// before flipping sign``            ``int` `sum = 0;` `            ``for` `(``int` `j = i; j < n; j++) ``            ``{``                ``// Calculate the sum of``                ``// original subarray``                ``sum += a[j];` `                ``// Subtract the original``                ``// subarray sum and add``                ``// the flipped subarray``                ``// sum to the total sum``                ``max_sum = Math.Max(max_sum,``                                   ``total_sum - 2 * sum);``            ``}``        ``}` `        ``// Return the max_sum``        ``return` `Math.Max(max_sum, total_sum);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr = { -2, 3, -1, -4, -2 };``        ``int` `N = arr.Length;` `        ``// Function call``        ``Console.WriteLine(maxSumFlip(arr, N));``    ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output
`8`

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

Efficient Approach: From the above approach, it can be observed that, to obtain maximum array sum, (2 * subarray sum) needs to be maximized for all subarrays. This can be done by using Dynamic Programming. Below are the steps:

1. Find the minimum sum subarray from l[] using Kadane’s Algorithm
2. This maximizes the contribution of (2 * sum) over all subarrays.
3. Add the maximum contribution to the total sum of the array.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find the maximum sum``// after flipping a subarray``int` `maxSumFlip(``int` `a[], ``int` `n)``{` `    ``// Stores the total sum of array``    ``int` `total_sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``total_sum += a[i];` `      ``// Kadane's algorithm to find the minimum subarray sum``    ``int` `b=0,temp=2e9;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``          ``b+=a[i];``          ``if``(temp>b)``          ``temp=b;``          ``if``(b>0)``          ``b=0;``    ``}` `    ``// Return the max_sum``    ``return` `max(total_sum,total_sum-2*temp);``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { -2, 3, -1, -4, -2 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(``int``);` `    ``cout << maxSumFlip(arr, N);``}`

## Java

 `import` `java.util.*;``import` `java.io.*;` `// Java program for the above approach``class` `GFG{` `  ``// Function to find the maximum sum``  ``// after flipping a subarray``  ``static` `int` `maxSumFlip(``int` `ar[], ``int` `n)``  ``{` `    ``// Stores the total sum of array``    ``int` `total_sum = ``0``;``    ``for` `(``int` `i = ``0` `; i < n ; i++){``      ``total_sum += ar[i];``    ``}` `    ``// Kadane's algorithm to find the minimum subarray sum``    ``int` `b = ``0``;``    ``int` `a = ``2000000000``;``    ``for` `(``int` `i = ``0` `; i < n ; i++)``    ``{``      ``b += ar[i];``      ``if``(a > b){``        ``a = b;``      ``}``      ``if``(b > ``0``){``        ``b = ``0``;``      ``}``    ``}` `    ``// Return the max_sum``    ``return` `Math.max(total_sum, total_sum - ``2``*a);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String args[])``  ``{``    ``int` `arr[] = ``new` `int``[]{ -``2``, ``3``, -``1``, -``4``, -``2` `};``    ``int` `N = arr.length;` `    ``System.out.println(maxSumFlip(arr, N));``  ``}``}` `// This code is contributed by entertain2022.`

## Python3

 `def` `maxsum(l,n):``  ``total_sum``=``sum``(l)``  ``#kadane's algorithm to find the minimum subarray sum``  ``current_sum``=``0``  ``minimum_sum``=``0``  ``for` `i ``in` `l:``    ``current_sum``+``=``i``    ``minimum_sum``=``min``(minimum_sum,current_sum)``    ``current_sum``=``min``(current_sum,``0``)``  ``return` `max``(total_sum,total_sum``-``2``*``minimum_sum)``l``=``[``-``2``,``3``,``-``1``,``-``4``,``-``2``]``n``=``len``(l)``print``(maxsum(l,n))`

## C#

 `// Include namespace system``using` `System;` `// C# program for the above approach``public` `class` `GFG``{``  ``// Function to find the maximum sum``  ``// after flipping a subarray``  ``public` `static` `int` `maxSumFlip(``int``[] ar, ``int` `n)``  ``{``    ` `    ``// Stores the total sum of array``    ``var` `total_sum = 0;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``total_sum += ar[i];``    ``}``    ` `    ``// Kadane's algorithm to find the minimum subarray sum``    ``var` `b = 0;``    ``var` `a = 2000000000;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``      ``b += ar[i];``      ``if` `(a > b)``      ``{``        ``a = b;``      ``}``      ``if` `(b > 0)``      ``{``        ``b = 0;``      ``}``    ``}``    ` `    ``// Return the max_sum``    ``return` `Math.Max(total_sum,total_sum - 2 * a);``  ``}``  ` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int``[] arr = ``new` `int``[]{-2, 3, -1, -4, -2};``    ``var` `N = arr.Length;``    ``Console.WriteLine(GFG.maxSumFlip(arr, N));``  ``}``}` `// This code is contributed by sourabhdalal0001.`

## Javascript

 ``

Output
`8`

Time Complexity: O(N)
Auxiliary Space: O(1)
Note: Can also be done by finding minimum subarray sum and print max(TotalSum, TotalSum-2*(minsubarraysum))

Previous
Next
Share your thoughts in the comments
Similar Reads