# 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;`   `        ``// Initialize sum of subarray` `        ``// after flipping sign` `        ``int` `flip_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``;`   `            ``// Initialize sum of subarray` `            ``// after flipping sign` `            ``int` `flip_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;` `        ``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`   `        ``# Initialize sum of subarray` `        ``# after flipping sign` `        ``flip_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;`   `        ``// Initialize sum of subarray` `        ``// after flipping sign` `        ``//int flip_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;` `    `  `    ``Console.WriteLine(maxSumFlip(arr, N));` `}` `}`   `// This code is contributed by 29AjayKumar`

Output:

```8

```

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

Efficient Approach: From the above approach, it can eb 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. Create a new array brr[], where brr[i] = (-1 * arr[i]) – arr[i]
2. Find the maximum sum subarray from brr[] using Kadane’s Algorithm
3. This maximizes the contribution of (2 * sum) over all subarrays.
4. Add the maximum contribution to the total sum of the array.

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) ` `{ ` `    `  `    ``// Find the total sum of array ` `    ``int` `total_sum = 0; ` `    `  `    ``for``(``int` `i = 0; i < n; i++) ` `        ``total_sum += a[i]; `   `    ``// Using Kadane's Algorithm ` `    ``int` `max_ending_here = -a - a; ` `    ``int` `curr_sum = -a - a; `   `    ``for``(``int` `i = 1; i < n; i++) ` `    ``{ ` `        `  `        ``// Either extend previous ` `        ``// sub_array or start ` `        ``// new subarray ` `        ``curr_sum = max(curr_sum + (-a[i] - a[i]), ` `                                  ``(-a[i] - a[i])); `   `        ``// Keep track of max_sum array ` `        ``max_ending_here = max(max_ending_here, ` `                              ``curr_sum); ` `    ``} `   `    ``// Add the sum to the total_sum ` `    ``int` `max_sum = total_sum + ` `                  ``max_ending_here; `   `    ``// Check max_sum was maximum ` `    ``// with flip or without flip ` `    ``max_sum = max(max_sum, total_sum); `   `    ``// Return max_sum ` `    ``return` `max_sum; ` `} `   `// Driver code   ` `int` `main()` `{` `    ``int` `arr[] = { -2, 3, -1, -4, -2 }; ` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr); `   `    ``// Function call ` `    ``cout << maxSumFlip(arr, N) << endl;`   `    ``return` `0;` `}`   `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java program for the above approach`   `import` `java.util.*;` `public` `class` `Main {`   `    ``// Function to find the maximum sum` `    ``// after flipping a subarray` `    ``public` `static` `int` `maxSumFlip(``int` `a[],` `                                 ``int` `n)` `    ``{` `        ``// Find the total sum of array` `        ``int` `total_sum = ``0``;` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``total_sum += a[i];`   `        ``// Using Kadane's Algorithm` `        ``int` `max_ending_here = -a[``0``] - a[``0``];` `        ``int` `curr_sum = -a[``0``] - a[``0``];`   `        ``for` `(``int` `i = ``1``; i < n; i++) {`   `            ``// Either extend previous` `            ``// sub_array or start` `            ``// new subarray` `            ``curr_sum` `                ``= Math.max(curr_sum + (-a[i] - a[i]),` `                           ``(-a[i] - a[i]));`   `            ``// Keep track of max_sum array` `            ``max_ending_here` `                ``= Math.max(max_ending_here,` `                           ``curr_sum);` `        ``}`   `        ``// Add the sum to the total_sum` `        ``int` `max_sum = total_sum` `                      ``+ max_ending_here;`   `        ``// Check max_sum was maximum` `        ``// with flip or without flip` `        ``max_sum = Math.max(max_sum, total_sum);`   `        ``// Return max_sum` `        ``return` `max_sum;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``int` `arr[] = { -``2``, ``3``, -``1``, -``4``, -``2` `};` `        ``int` `N = a.length;`   `        ``// Function Call` `        ``System.out.println(maxSumFlip(arr, N));` `    ``}` `}`

## 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)` `{` `    `  `    ``// Find the total sum of array` `    ``int` `total_sum = 0;` `    ``for``(``int` `i = 0; i < n; i++)` `        ``total_sum += a[i];`   `    ``// Using Kadane's Algorithm` `    ``int` `max_ending_here = -a - a;` `    ``int` `curr_sum = -a - a;`   `    ``for``(``int` `i = 1; i < n; i++)` `    ``{`   `        ``// Either extend previous` `        ``// sub_array or start` `        ``// new subarray` `        ``curr_sum = Math.Max(curr_sum + ` `                        ``(-a[i] - a[i]),` `                        ``(-a[i] - a[i]));`   `        ``// Keep track of max_sum array` `        ``max_ending_here = Math.Max(` `                          ``max_ending_here,` `                          ``curr_sum);` `    ``}`   `    ``// Add the sum to the total_sum` `    ``int` `max_sum = total_sum +` `                  ``max_ending_here;`   `    ``// Check max_sum was maximum` `    ``// with flip or without flip` `    ``max_sum = Math.Max(max_sum,` `                       ``total_sum);`   `    ``// Return max_sum` `    ``return` `max_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`

Output:

```8

```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

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.