Maximize array sum after K negations using Sorting
Last Updated :
09 Feb, 2024
Given an array of size n and a number k. We must modify array K a 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, the sum of the array must be maximum?
Examples :
Input : arr[] = {-2, 0, 5, -1, 2}, K = 4
Output: 10
Explanation:
1. Replace (-2) by -(-2), array becomes {2, 0, 5, -1, 2}
2. Replace (-1) by -(-1), array becomes {2, 0, 5, 1, 2}
3. Replace (0) by -(0), array becomes {2, 0, 5, 1, 2}
4. Replace (0) by -(0), array becomes {2, 0, 5, 1, 2}
Input : arr[] = {9, 8, 8, 5}, K = 3
Output: 20
Naive approach: This problem has a very simple solution, we just have to replace the minimum element arr[i] in the array by -arr[i] for the current operation. In this way, we can make sum of the array maximum after K operations. One interesting case is, that once the minimum element becomes 0, we don’t need to make any more changes.
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int maximumSum( int arr[], int n, int k)
{
for ( int i = 1; i <= k; i++) {
int min = INT_MAX;
int index = -1;
for ( int j = 0; j < n; j++) {
if (arr[j] < min) {
min = arr[j];
index = j;
}
}
if (min == 0)
break ;
arr[index] = -arr[index];
}
int sum = 0;
for ( int i = 0; i < n; i++)
sum += arr[i];
return sum;
}
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;
}
|
C
#include<stdio.h>
#include<stdlib.h>
#include <limits.h>
int maximumSum( int arr[], int n, int k)
{
for ( int i = 1; i <= k; i++) {
int min = INT_MAX;
int index = -1;
for ( int j = 0; j < n; j++) {
if (arr[j] < min) {
min = arr[j];
index = j;
}
}
if (min == 0)
break ;
arr[index] = -arr[index];
}
int sum = 0;
for ( int i = 0; i < n; i++)
sum += arr[i];
return sum;
}
int main()
{
int arr[] = { -2, 0, 5, -1, 2 };
int k = 4;
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "%d" ,maximumSum(arr, n, k));
return 0;
}
|
Java
class GFG {
static int maximumSum( int arr[], int n, int k)
{
for ( int i = 1 ; i <= k; i++) {
int min = + 2147483647 ;
int index = - 1 ;
for ( int j = 0 ; j < n; j++) {
if (arr[j] < min) {
min = arr[j];
index = j;
}
}
if (min == 0 )
break ;
arr[index] = -arr[index];
}
int sum = 0 ;
for ( int i = 0 ; i < n; i++)
sum += arr[i];
return sum;
}
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));
}
}
|
Python3
def maximumSum(arr, n, k):
for i in range ( 1 , k + 1 ):
min = + 2147483647
index = - 1
for j in range (n):
if (arr[j] < min ):
min = arr[j]
index = j
if ( min = = 0 ):
break
arr[index] = - arr[index]
sum = 0
for i in range (n):
sum + = arr[i]
return sum
arr = [ - 2 , 0 , 5 , - 1 , 2 ]
k = 4
n = len (arr)
print (maximumSum(arr, n, k))
|
C#
using System;
class GFG {
static int maximumSum( int [] arr, int n, int k)
{
for ( int i = 1; i <= k; i++)
{
int min = +2147483647;
int index = -1;
for ( int j = 0; j < n; j++)
{
if (arr[j] < min)
{
min = arr[j];
index = j;
}
}
if (min == 0)
break ;
arr[index] = -arr[index];
}
int sum = 0;
for ( int i = 0; i < n; i++)
sum += arr[i];
return sum;
}
public static void Main()
{
int [] arr = { -2, 0, 5, -1, 2 };
int k = 4;
int n = arr.Length;
Console.Write(maximumSum(arr, n, k));
}
}
|
Javascript
<script>
function maximumSum(arr, n, k)
{
for (let i = 1; i <= k; i++)
{
let min = +2147483647;
let index = -1;
for (let j = 0; j < n; j++)
{
if (arr[j] < min)
{
min = arr[j];
index = j;
}
}
if (min == 0)
break ;
arr[index] = -arr[index];
}
let sum = 0;
for (let i = 0; i < n; i++)
sum += arr[i];
return sum;
}
let arr = [ -2, 0, 5, -1, 2 ];
let k = 4;
let n = arr.length;
document.write(maximumSum(arr, n, k));
</script>
|
PHP
<?php
function maximumSum( $arr , $n , $k )
{
$INT_MAX = 0;
for ( $i = 1; $i <= $k ; $i ++)
{
$min = $INT_MAX ;
$index = -1;
for ( $j = 0; $j < $n ; $j ++)
{
if ( $arr [ $j ] < $min )
{
$min = $arr [ $j ];
$index = $j ;
}
}
if ( $min == 0)
break ;
$arr [ $index ] = - $arr [ $index ];
}
$sum = 0;
for ( $i = 0; $i < $n ; $i ++)
$sum += $arr [ $i ];
return $sum ;
}
$arr = array (-2, 0, 5, -1, 2);
$k = 4;
$n = sizeof( $arr ) / sizeof( $arr [0]);
echo maximumSum( $arr , $n , $k );
?>
|
Time Complexity: O(k*n)
Auxiliary Space: O(1)
Approach 2 (Using Sort): When there is a need to negate at most k elements.
Follow the steps below to solve this problem:
- Sort the given array arr.
- Then for a given value of k, Iterate through the array till k remains greater than 0, If the value of the 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 an array greater than 0 we will change the 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.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int sol( int arr[], int n, int k)
{
int sum = 0;
int i = 0;
sort(arr, arr + n);
while (k > 0) {
if (arr[i] >= 0)
break ;
else {
arr[i] = (-1) * arr[i];
k = k - 1;
}
i++;
}
int minpos=INT_MAX;
for ( int j = 0; j < n; j++)
{
if (arr[j]>=0)
minpos=min(minpos,arr[j]);
sum += arr[j];
}
if (minpos==0 || k%2==0)
return sum;
return (sum-2*minpos);
}
int main()
{
int arr[] = {-2, 0, 5, -1, 2};
int n = sizeof (arr) / sizeof (arr[0]);
cout << sol(arr, n, 4) << endl;
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
int cmpfunc( const void * a, const void * b)
{
return (*( int *)a - *( int *)b);
}
int sol( int arr[], int n, int k)
{
int sum = 0;
int i = 0;
qsort (arr, n, sizeof ( int ), cmpfunc);
while (k > 0) {
if (arr[i] >= 0)
k = 0;
else {
arr[i] = (-1) * arr[i];
k = k - 1;
}
i++;
}
for ( int j = 0; j < n; j++)
sum += arr[j];
return sum;
}
int main()
{
int arr[] = { -2, 0, 5, -1, 2 };
int n = sizeof (arr) / sizeof (arr[0]);
printf ( "%d" , sol(arr, n, 4));
return 0;
}
|
Java
import java.util.Arrays;
public class GFG {
static int sol( int arr[], int k)
{
Arrays.sort(arr);
int sum = 0 ;
int i = 0 ;
while (k > 0 ) {
if (arr[i] >= 0 )
k = 0 ;
else {
arr[i] = (- 1 ) * arr[i];
k = k - 1 ;
}
i++;
}
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 ));
}
}
|
Python3
def sol(arr, k):
arr.sort()
Sum = 0
i = 0
while (k > 0 ):
if (arr[i] > = 0 ):
k = 0
else :
arr[i] = ( - 1 ) * arr[i]
k = k - 1
i + = 1
for j in range ( len (arr)):
Sum + = arr[j]
return Sum
arr = [ - 2 , 0 , 5 , - 1 , 2 ]
print (sol(arr, 4 ))
|
C#
using System;
class GFG{
static int sol( int []arr, int k)
{
Array.Sort(arr);
int sum = 0;
int i = 0;
while (k > 0)
{
if (arr[i] >= 0)
k = 0;
else
{
arr[i] = (-1) * arr[i];
k = k - 1;
}
i++;
}
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 };
Console.Write(sol(arr, 4));
}
}
|
Javascript
<script>
function sol(arr, k)
{
arr.sort();
let sum = 0;
let i = 0;
while (k > 0)
{
if (arr[i] >= 0)
k = 0;
else
{
arr[i] = (-1) * arr[i];
k = k - 1;
}
i++;
}
for (let j = 0; j < arr.length; j++)
{
sum += arr[j];
}
return sum;
}
let arr = [ -2, 0, 5, -1, 2 ];
document.write(sol(arr, 4));
</script>
|
Time Complexity: O(n*logn)
Auxiliary Space: O(1)
Approach 3(Using Sort):
The above approach 2 is optimal when there is a need to negate at most k elements. To solve when there are exactly k negations the algorithm is given below.
- Sort the array in ascending order. Initialize i = 0.
- Increment i and multiply all negative elements by -1 till k becomes or a positive element is reached.
- Check if the end of the array has occurred. If true then go to (n-1)th element.
- If k ==0 or k is even, return the sum of all elements. Else multiply the absolute of minimum of ith or (i-1) th element by -1.
- Return sum of the array.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long long int sumArray( long long int * arr, int n)
{
long long int sum = 0;
for ( int i = 0; i < n; i++)
sum += arr[i];
return sum;
}
long long int maximizeSum( long long int arr[], int n, int k)
{
sort(arr, arr + n);
int i = 0;
for (i = 0; i < n; i++) {
if (k && arr[i] < 0) {
arr[i] *= -1;
k--;
continue ;
}
break ;
}
if (i == n)
i--;
if (k == 0 || k % 2 == 0)
return sumArray(arr, n);
if (i != 0 && abs (arr[i]) >= abs (arr[i - 1]))
i--;
arr[i] *= -1;
return sumArray(arr, n);
}
int main()
{
int n = 5;
int k = 4;
long long int arr[5] = { -2, 0, 5, -1, 2 };
cout << maximizeSum(arr, n, k) << endl;
return 0;
}
|
C
#include <stdio.h>
#include<stdlib.h>
long long int sumArray( long long int * arr, int n)
{
long long int sum = 0;
for ( int i = 0; i < n; i++)
sum += arr[i];
return sum;
}
void merge( long long int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1 + j];
i = 0;
j = 0;
k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
}
else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort( long long int arr[], int l, int r)
{
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
long long int maximizeSum( long long int arr[], int n, int k)
{
mergeSort(arr,0,n-1);
int i = 0;
for (i = 0; i < n; i++) {
if (k && arr[i] < 0) {
arr[i] *= -1;
k--;
continue ;
}
break ;
}
if (i == n)
i--;
if (k == 0 || k % 2 == 0)
return sumArray(arr, n);
if (i != 0 && abs (arr[i]) >= abs (arr[i - 1]))
i--;
arr[i] *= -1;
return sumArray(arr, n);
}
int main()
{
int n = 5;
int k = 4;
long long int arr[] = { -2, 0, 5, -1, 2 };
printf ( "%lld" ,maximizeSum(arr,n,k));
return 0;
}
|
Java
import java.util.*;
class GFG {
static int sumArray( int [] arr, int n)
{
int sum = 0 ;
for ( int i = 0 ; i < n; i++)
sum += arr[i];
return sum;
}
static int maximizeSum( int arr[], int n, int k)
{
Arrays.sort(arr);
int i = 0 ;
for (i = 0 ; i < n; i++) {
if (k != 0 && arr[i] < 0 ) {
arr[i] *= - 1 ;
k--;
continue ;
}
break ;
}
if (i == n)
i--;
if (k == 0 || k % 2 == 0 )
return sumArray(arr, n);
if (i != 0 && Math.abs(arr[i]) >= Math.abs(arr[i - 1 ]))
i--;
arr[i] *= - 1 ;
return sumArray(arr, n);
}
public static void main(String args[])
{
int n = 5 ;
int arr[] = { - 2 , 0 , 5 , - 1 , 2 };
int k = 4 ;
System.out.print(maximizeSum(arr, n, k));
}
}
|
Python3
def sumArray(arr, n):
sum = 0
for i in range (n):
sum + = arr[i]
return sum
def maximizeSum(arr, n, k):
arr.sort()
i = 0
for i in range (n):
if (k and arr[i] < 0 ):
arr[i] * = - 1
k - = 1
continue
break
if (i = = n):
i - = 1
if (k = = 0 or k % 2 = = 0 ):
return sumArray(arr, n)
if (i ! = 0 and abs (arr[i]) > = abs (arr[i - 1 ])):
i - = 1
arr[i] * = - 1
return sumArray(arr, n)
n = 5
k = 4
arr = [ - 2 , 0 , 5 , - 1 , 2 ]
print (maximizeSum(arr, n, k))
|
C#
using System;
class GFG{
static int sumArray( int [] arr, int n)
{
int sum = 0;
for ( int i = 0; i < n; i++)
{
sum += arr[i];
}
return sum;
}
static int maximizeSum( int [] arr, int n, int k)
{
Array.Sort(arr);
int i = 0;
for (i = 0; i < n; i++)
{
if (k != 0 && arr[i] < 0)
{
arr[i] *= -1;
k--;
continue ;
}
break ;
}
if (i == n)
i--;
if (k == 0 || k % 2 == 0)
{
return sumArray(arr, n);
}
if (i != 0 && Math.Abs(arr[i]) >=
Math.Abs(arr[i - 1]))
{
i--;
}
arr[i] *= -1;
return sumArray(arr, n);
}
static public void Main()
{
int n = 5;
int [] arr = { -2, 0, 5, -1, 2 };
int k = 4;
Console.Write(maximizeSum(arr, n, k));
}
}
|
Javascript
<script>
function sumArray(arr,n)
{
let sum = 0;
for (let i = 0; i < n; i++)
{
sum += arr[i];
}
return sum;
}
function maximizeSum(arr,n,k)
{
(arr).sort( function (a,b){ return a-b;});
let i = 0;
for (i = 0; i < n; i++)
{
if (k != 0 && arr[i] < 0)
{
arr[i] *= -1;
k--;
continue ;
}
break ;
}
if (i == n)
i--;
if (k == 0 || k % 2 == 0)
{
return sumArray(arr, n);
}
if (i != 0 && Math.abs(arr[i]) >=
Math.abs(arr[i - 1]))
{
i--;
}
arr[i] *= -1;
return sumArray(arr, n);
}
let n = 5;
let k = 4;
let arr=[ -2, 0, 5, -1, 2 ];
document.write(maximizeSum(arr, n, k));
</script>
|
Time Complexity: O(n*logn)
Auxiliary Space: O(1)
Maximize array sum after K negations | Set 2
If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Share your thoughts in the comments
Please Login to comment...