# Maximize array sum after K negations | Set 1

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
```

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

This problem has very simple solution, we just have 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.

## C++

 `// C++ program to maximize array sum after ` `// k operations. ` `#include ` `using` `namespace` `std; ` ` `  `// This function does k operations on array ` `// in a way that maximize the array sum. ` `// index --> stores the index of current minimum ` `// element for j'th operation ` `int` `maximumSum(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``// Modify array K number of times ` `    ``for` `(``int` `i = 1; i <= k; i++) { ` `        ``int` `min = INT_MAX; ` `        ``int` `index = -1; ` ` `  `        ``// Find minimum element in array for ` `        ``// current operation and modify it ` `        ``// i.e; arr[j] --> -arr[j] ` `        ``for` `(``int` `j = 0; j < n; j++) { ` `            ``if` `(arr[j] < min) { ` `                ``min = arr[j]; ` `                ``index = j; ` `            ``} ` `        ``} ` ` `  `        ``// this the condition if we find 0 as ` `        ``// minimum element, so it will useless to ` `        ``// replace 0 by -(0) for remaining operations ` `        ``if` `(min == 0) ` `            ``break``; ` ` `  `        ``// Modify element of array ` `        ``arr[index] = -arr[index]; ` `    ``} ` ` `  `    ``// Calculate sum of array ` `    ``int` `sum = 0; ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``sum += arr[i]; ` `    ``return` `sum; ` `} ` ` `  `// Driver program to test the case ` `int` `main() ` `{ ` `    ``int` `arr[] = { -2, 0, 5, -1, 2 }; ` `    ``int` `k = 4; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ` `    ``cout << maximumSum(arr, n, k); ` `    ``return` `0; ` `} `

## Java

 `// Java program to maximize array ` `// sum after k operations. ` ` `  `class` `GFG { ` `    ``// This function does k operations ` `    ``// on array in a way that maximize ` `    ``// the array sum. index --> stores ` `    ``// the index of current minimum ` `    ``// element for j'th operation ` `    ``static` `int` `maximumSum(``int` `arr[], ``int` `n, ``int` `k) ` `    ``{ ` `        ``// Modify array K number of times ` `        ``for` `(``int` `i = ``1``; i <= k; i++) { ` `            ``int` `min = +``2147483647``; ` `            ``int` `index = -``1``; ` ` `  `            ``// Find minimum element in array for ` `            ``// current operation and modify it ` `            ``// i.e; arr[j] --> -arr[j] ` `            ``for` `(``int` `j = ``0``; j < n; j++) { ` `                ``if` `(arr[j] < min) { ` `                    ``min = arr[j]; ` `                    ``index = j; ` `                ``} ` `            ``} ` ` `  `            ``// this the condition if we find 0 as ` `            ``// minimum element, so it will useless to ` `            ``// replace 0 by -(0) for remaining operations ` `            ``if` `(min == ``0``) ` `                ``break``; ` ` `  `            ``// Modify element of array ` `            ``arr[index] = -arr[index]; ` `        ``} ` ` `  `        ``// Calculate sum of array ` `        ``int` `sum = ``0``; ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `            ``sum += arr[i]; ` `        ``return` `sum; ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `main(String arg[]) ` `    ``{ ` `        ``int` `arr[] = { -``2``, ``0``, ``5``, -``1``, ``2` `}; ` `        ``int` `k = ``4``; ` `        ``int` `n = arr.length; ` `        ``System.out.print(maximumSum(arr, n, k)); ` `    ``} ` `} ` ` `  `// This code is contributed by Anant Agarwal. `

## Python3

 `# Python3 program to maximize  ` `# array sum after k operations. ` ` `  `# This function does k operations on array ` `# in a way that maximize the array sum. ` `# index --> stores the index of current  ` `# minimum element for j'th operation ` `def` `maximumSum(arr, n, k): ` ` `  `    ``# Modify array K number of times ` `    ``for` `i ``in` `range``(``1``, k ``+` `1``): ` `     `  `        ``min` `=` `+``2147483647` `        ``index ``=` `-``1` ` `  `        ``# Find minimum element in array for ` `        ``# current operation and modify it ` `        ``# i.e; arr[j] --> -arr[j] ` `        ``for` `j ``in` `range``(n): ` `         `  `            ``if` `(arr[j] < ``min``): ` `             `  `                ``min` `=` `arr[j] ` `                ``index ``=` `j ` ` `  `        ``# this the condition if we find 0 as ` `        ``# minimum element, so it will useless to ` `        ``# replace 0 by -(0) for remaining operations ` `        ``if` `(``min` `=``=` `0``): ` `            ``break` ` `  `        ``# Modify element of array ` `        ``arr[index] ``=` `-``arr[index] ` `     `  ` `  `    ``# Calculate sum of array ` `    ``sum` `=` `0` `    ``for` `i ``in` `range``(n): ` `        ``sum` `+``=` `arr[i] ` `    ``return` `sum` ` `  `# Driver program ` `arr ``=` `[``-``2``, ``0``, ``5``, ``-``1``, ``2``] ` `k ``=` `4` `n ``=` `len``(arr) ` `print``(maximumSum(arr, n, k)) ` ` `  `# This code is contributed by Anant Agarwal. `

## C#

 `// C# program to maximize array ` `// sum after k operations. ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// This function does k operations ` `    ``// on array in a way that maximize ` `    ``// the array sum. index --> stores ` `    ``// the index of current minimum ` `    ``// element for j'th operation ` `    ``static` `int` `maximumSum(``int``[] arr, ``int` `n, ` `                          ``int` `k) ` `    ``{ ` ` `  `        ``// Modify array K number of times ` `        ``for` `(``int` `i = 1; i <= k; i++) { ` `            ``int` `min = +2147483647; ` `            ``int` `index = -1; ` ` `  `            ``// Find minimum element in array for ` `            ``// current operation and modify it ` `            ``// i.e; arr[j] --> -arr[j] ` `            ``for` `(``int` `j = 0; j < n; j++) { ` `                ``if` `(arr[j] < min) { ` `                    ``min = arr[j]; ` `                    ``index = j; ` `                ``} ` `            ``} ` ` `  `            ``// this the condition if we find ` `            ``// 0 as minimum element, so it ` `            ``// will useless to replace 0 by -(0) ` `            ``// for remaining operations ` `            ``if` `(min == 0) ` `                ``break``; ` ` `  `            ``// Modify element of array ` `            ``arr[index] = -arr[index]; ` `        ``} ` ` `  `        ``// Calculate sum of array ` `        ``int` `sum = 0; ` `        ``for` `(``int` `i = 0; i < n; i++) ` `            ``sum += arr[i]; ` `        ``return` `sum; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int``[] arr = { -2, 0, 5, -1, 2 }; ` `        ``int` `k = 4; ` `        ``int` `n = arr.Length; ` `        ``Console.Write(maximumSum(arr, n, k)); ` `    ``} ` `} ` ` `  `// This code is contributed by Nitin Mittal. `

## PHP

 ` stores ` `// the index of current minimum ` `// element for j'th operation ` `function` `maximumSum(``\$arr``, ``\$n``, ``\$k``) ` `{ ` `    ``\$INT_MAX` `= 0; ` `    ``// Modify array K ` `    ``// number of times ` `    ``for` `(``\$i` `= 1; ``\$i` `<= ``\$k``; ``\$i``++) ` `    ``{ ` `        ``\$min` `= ``\$INT_MAX``; ` `        ``\$index` `= -1; ` ` `  `        ``// Find minimum element in  ` `        ``// array for current operation ` `        ``// and modify it i.e;  ` `        ``// arr[j] --> -arr[j] ` `        ``for` `(``\$j` `= 0; ``\$j` `< ``\$n``; ``\$j``++) ` `        ``{ ` `            ``if` `(``\$arr``[``\$j``] < ``\$min``) ` `            ``{ ` `                ``\$min` `= ``\$arr``[``\$j``]; ` `                ``\$index` `= ``\$j``; ` `            ``} ` `        ``} ` ` `  `        ``// this the condition if we ` `        ``// find 0 as minimum element, so  ` `        ``// it will useless to replace 0  ` `        ``// by -(0) for remaining operations ` `        ``if` `(``\$min` `== 0) ` `            ``break``; ` ` `  `        ``// Modify element of array ` `        ``\$arr``[``\$index``] = -``\$arr``[``\$index``]; ` `    ``} ` ` `  `    ``// Calculate sum of array ` `    ``\$sum` `= 0; ` `    ``for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `        ``\$sum` `+= ``\$arr``[``\$i``]; ` `    ``return` `\$sum``; ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(-2, 0, 5, -1, 2); ` `\$k` `= 4; ` `\$n` `= sizeof(``\$arr``) / sizeof(``\$arr``[0]); ` `echo` `maximumSum(``\$arr``, ``\$n``, ``\$k``); ` `     `  `// This code is contributed ` `// by nitin mittal.  ` `?> `

Output :

```10
```

Time Complexity : O(k*n)
Auxiliary Space : O(1)

Approach 2 (Using Sort):
This approach is somewhat better than the above discussed method. In this method we will first sort the given array using java in-built sort function which has worst running time complexity of O(nlogn). Then for a given value of k we will continue to iterate through the array till k remains greater than 0, If value of array at any index is less than 0 we will change its sign and decrement k by 1. If we find a 0 in the array we will immediately set k equal to 0 to maximize our result. In some cases if we have all the values in array greater than 0 we will change sign of positive values, as our array is already sorted we will be changing signs of lower values present in the array which will eventually maximize our sum.

 `// Java program to find maximum array sum  ` `// after at most k negations. ` `import` `java.util.Arrays; ` ` `  `public` `class` `GFG { ` ` `  `    ``static` `int` `sol(``int` `arr[], ``int` `k) ` `    ``{ ` `        ``// sorting given array using in-built java sort function ` `        ``Arrays.sort(arr); ` `        ``int` `sum = ``0``; ` ` `  `        ``int` `i = ``0``; ` `        ``while` `(k > ``0``) { ` ` `  `            ``// If we find a 0 in our ` `            ``// sorted array, we stop ` `            ``if` `(arr[i] == ``0``) ` `                ``k = ``0``; ` ` `  `            ``else` `{ ` `                ``arr[i] = (-``1``) * arr[i]; ` `                ``k = k - ``1``; ` `            ``} ` ` `  `            ``i++; ` `        ``} ` ` `  `        ``// calculating sum ` `        ``for` `(``int` `j = ``0``; j < arr.length; j++) { ` `            ``sum += arr[j]; ` `        ``} ` `        ``return` `sum; ` `    ``} ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `arr[] = { -``2``, ``0``, ``5``, -``1``, ``2` `}; ` `        ``System.out.println(sol(arr, ``4``)); ` `    ``} ` `} `

Time Complexity : O(n*logn)
Auxiliary Space : O(1)

Maximize array sum after K negations | Set 2

This article is contributed by Shashank Mishra ( Gullu ). 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.

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.