# Maximize array sum after K negations | Set 2

Given an array of size n and a number k. We must modify array K number of times. Here modify array means in each operation we can replace any array element arr[i] by -arr[i]. We need to perform this operation in such a way that after K operations, sum of array must be maximum?

Examples:

Input : arr[] = {-2, 0, 5, -1, 2} K = 4 Output: 10 // Replace (-2) by -(-2), array becomes {2, 0, 5, -1, 2} // Replace (-1) by -(-1), array becomes {2, 0, 5, 1, 2} // Replace (0) by -(0), array becomes {2, 0, 5, 1, 2} // Replace (0) by -(0), array becomes {2, 0, 5, 1, 2} Input : arr[] = {9, 8, 8, 5} K = 3 Output: 20

## We strongly recommend that you click here and practice it, before moving on to the solution.

We have discussed a O(nk) solution in below post.

Maximize array sum after K negations | Set 1

The idea used in above post is to replace the minimum element arr[i] in array by -arr[i] for current operation. In this way we can make sum of array maximum after K operations. Once interesting case is, once minimum element becomes 0, we don’t need to make any more changes.

The implementation used in above solution uses linear search to find minimum element. The time complexity of the above discussed solution is O(nk)

In this post an optimized solution is implemented that uses a priority queue (or binary heap) to find minimum element quickly.

Below is Java implementation of the idea. It uses PriorityQueue class in Java.

`// A PriorityQueue based Java program to maximize array ` `// sum after k negations. ` `import` `java.util.*; ` ` ` `class` `maximizeSum ` `{ ` ` ` `public` `static` `int` `maxSum(` `int` `[] a, ` `int` `k) ` ` ` `{ ` ` ` `// Create a priority queue and insert all array elements ` ` ` `// int ` ` ` `PriorityQueue<Integer> pq = ` `new` `PriorityQueue<>(); ` ` ` `for` `(` `int` `x : a) ` ` ` `pq.add(x); ` ` ` ` ` `// Do k negations by removing a minimum element k times ` ` ` `while` `(k-- > ` `0` `) ` ` ` `{ ` ` ` `// Retrieve and remove min element ` ` ` `int` `temp = pq.poll(); ` ` ` ` ` `// Modify the minimum element and add back ` ` ` `// to priority queue ` ` ` `temp *= -` `1` `; ` ` ` `pq.add(temp); ` ` ` `} ` ` ` ` ` `// Compute sum of all elements in priority queue. ` ` ` `int` `sum = ` `0` `; ` ` ` `for` `(` `int` `x : pq) ` ` ` `sum += x; ` ` ` `return` `sum; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main (String[] args) ` ` ` `{ ` ` ` `int` `[] arr = {-` `2` `, ` `0` `, ` `5` `, -` `1` `, ` `2` `}; ` ` ` `int` `k = ` `4` `; ` ` ` `System.out.println(maxSum(arr, k)); ` ` ` `} ` `} ` |

*chevron_right*

*filter_none*

**Output:**

10

This article is contributed by **Prakhar**. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: **DSA Self Paced**. Become industry ready at a student-friendly price.

## Recommended Posts:

- Maximize array sum after K negations | Set 1
- Maximize the size of array by deleting exactly k sub-arrays to make array prime
- Rearrange the array to maximize the number of primes in prefix sum of the array
- Maximize the median of the given array after adding K elements to the same array
- Maximize Array sum by swapping at most K elements with another array
- Maximize the sum of array by multiplying prefix of array with -1
- Maximize value of (a[i]+i)*(a[j]+j) in an array
- Maximize value of (arr[i] - i) - (arr[j] - j) in an array
- Maximize elements using another array
- Maximize the median of an array
- Given an array and three numbers, maximize (x * a[i]) + (y * a[j]) + (z * a[k])
- Maximize the bitwise OR of an array
- Rearrange an array to maximize i*arr[i]
- Remove an element to maximize the GCD of the given array
- Maximize the sum of sum of the Array by removing end elements
- Maximize the sum of modulus with every Array element
- Remove array end element to maximize the sum of product
- Maximize array sum by X increments when each element is divided by 10
- Maximize the sum of array after multiplying a prefix and suffix by -1
- Maximize the numbers of splits in an Array having sum divisible by 3