Maximize Array Sum After k Negations

Given an array arr[] of size n and an integer k. We must modify array k number of times. In each modification, we can replace any array element arr[i] by -arr[i]. The task is to perform this operation in such a way that after k operations, the sum of the array is maximum.

Examples :

Input: arr[] = [1, 2, -3, 4, 5], k = 1
Output: 15
Explanation: Change -3 to 3. The resulting array is [1, 2, 3, 4, 5], whose sum is 15.
Input: arr[] = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20], k = 5
Output: 68
Explanation: Change -12, -4, and -2 to positive values using three operations. The remaining two operations can be performed on the same element, changing its sign twice. Therefore, the maximum sum remains 68.

Try It Yourself

Table of Content

[Naive Approach] Using Recursion - O(n^k × n) time and O(k) space
[Better Approach] Repeatedly Negate the Minimum Element - O(n × k) Time and O(1) Space
[Expected Approach] Using Sorting and Greedy - O(n log n) Time and O(1) Space

[Naive Approach] Using Recursion - O(n^k × n) time and O(k) space

For every operation, try negating each array element one by one. After performing exactly k operations, calculate the array sum and return the maximum possible value.
Since every operation has n choices, this approach explores all possible sequences of negations.

C++

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

int solve(vector<int>& arr, int k) {
    if (k == 0) {
        int sum = 0;

        for (int value : arr) {
            sum += value;
        }

        return sum;
    }

    int maxSum = INT_MIN;

    // Try negating every element for the current operation.
    for (int i = 0; i < arr.size(); i++) {
        arr[i] = -arr[i];

        maxSum = max(maxSum, solve(arr, k - 1));

        // Restore the element for the next choice.
        arr[i] = -arr[i];
    }

    return maxSum;
}

int maximizeSum(vector<int>& arr, int k) {
    return solve(arr, k);
}

int main() {
    vector<int> arr1 = {1, 2, -3, 4, 5};
    int k1 = 1;
    cout << maximizeSum(arr1, k1) << endl;

    vector<int> arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
    int k2 = 5;
    cout << maximizeSum(arr2, k2) << endl;

    return 0;
}

Java

class GFG {
    static int solve(int[] arr, int k) {
        if (k == 0) {
            int sum = 0;

            for (int value : arr) {
                sum += value;
            }

            return sum;
        }

        int maxSum = Integer.MIN_VALUE;

        // Try negating every element for the current operation.
        for (int i = 0; i < arr.length; i++) {
            arr[i] = -arr[i];

            maxSum = Math.max(maxSum, solve(arr, k - 1));

            // Restore the element for the next choice.
            arr[i] = -arr[i];
        }

        return maxSum;
    }

    static int maximizeSum(int[] arr, int k) {
        return solve(arr, k);
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        System.out.println(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        System.out.println(maximizeSum(arr2, k2));
    }
}

Python

def solve(arr, k):
    if k == 0:
        return sum(arr)

    max_sum = float("-inf")

    # Try negating every element for the current operation.
    for i in range(len(arr)):
        arr[i] = -arr[i]

        max_sum = max(max_sum, solve(arr, k - 1))

        # Restore the element for the next choice.
        arr[i] = -arr[i]

    return max_sum


def maximizeSum(arr, k):
    return solve(arr, k)

if __name__ == "__main__":
    arr1 = [1, 2, -3, 4, 5]
    k1 = 1
    print(maximizeSum(arr1, k1))
    
    arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20]
    k2 = 5
    print(maximizeSum(arr2, k2))

using System;

class GFG {
    static int Solve(int[] arr, int k) {
        if (k == 0) {
            int sum = 0;

            foreach (int value in arr) {
                sum += value;
            }

            return sum;
        }

        int maxSum = int.MinValue;

        // Try negating every element for the current operation.
        for (int i = 0; i < arr.Length; i++) {
            arr[i] = -arr[i];

            maxSum = Math.Max(maxSum, Solve(arr, k - 1));

            // Restore the element for the next choice.
            arr[i] = -arr[i];
        }

        return maxSum;
    }

    static int maximizeSum(int[] arr, int k) {
        return Solve(arr, k);
    }

    static void Main() {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        Console.WriteLine(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        Console.WriteLine(maximizeSum(arr2, k2));
    }
}

JavaScript

/**
 * @param {number[]} arr
 * @param {number} k
 * @returns {number}
 */
function solve(arr, k) {
    if (k === 0) {
        let sum = 0;

        for (const value of arr) {
            sum += value;
        }

        return sum;
    }

    let maxSum = -Infinity;

    // Try negating every element for the current operation.
    for (let i = 0; i < arr.length; i++) {
        arr[i] = -arr[i];

        maxSum = Math.max(maxSum, solve(arr, k - 1));

        // Restore the element for the next choice.
        arr[i] = -arr[i];
    }

    return maxSum;
}

/**
 * @param {number[]} arr
 * @param {number} k
 * @returns {number}
 */
function maximizeSum(arr, k) {
    return solve(arr, k);
}

// Driver Code
const arr1 = [1, 2, -3, 4, 5];
const k1 = 1;
console.log(maximizeSum(arr1, k1));

const arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20];
const k2 = 5;
console.log(maximizeSum(arr2, k2));

Output

15
68

[Better Approach] Repeatedly Negate the Minimum Element - O(n × k) Time and O(1) Space

For every operation, find the smallest element in the array and negate it. Negating the smallest element gives the maximum possible increase in the array sum:
Negating a negative value increases the sum.
When all values are non-negative, negating the smallest value causes the minimum possible reduction.
Repeat this process exactly k times and then calculate the final sum.

C++

#include <iostream>
#include <vector>
using namespace std;

int maximizeSum(vector<int>& arr, int k) {
    int n = arr.size();

    while (k-- > 0) {
        int minIndex = 0;

        // Find the minimum element in the array.
        for (int i = 1; i < n; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }

        // Negate the minimum element.
        arr[minIndex] = -arr[minIndex];
    }

    int sum = 0;

    for (int value : arr) {
        sum += value;
    }

    return sum;
}

int main() {
    vector<int> arr1 = {1, 2, -3, 4, 5};
    int k1 = 1;
    cout << maximizeSum(arr1, k1) << endl;

    vector<int> arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
    int k2 = 5;
    cout << maximizeSum(arr2, k2) << endl;

    return 0;
}

Java

import java.util.*;

class GFG {
    static int maximizeSum(int[] arr, int k) {
        int n = arr.length;

        while (k-- > 0) {
            int minIndex = 0;

            // Find the minimum element in the array.
            for (int i = 1; i < n; i++) {
                if (arr[i] < arr[minIndex]) {
                    minIndex = i;
                }
            }

            // Negate the minimum element.
            arr[minIndex] = -arr[minIndex];
        }

        int sum = 0;

        for (int value : arr) {
            sum += value;
        }

        return sum;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        System.out.println(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        System.out.println(maximizeSum(arr2, k2));
    }
}

Python

def maximizeSum(arr, k):
    n = len(arr)

    while k > 0:
        min_index = 0

        # Find the minimum element in the array.
        for i in range(1, n):
            if arr[i] < arr[min_index]:
                min_index = i

        # Negate the minimum element.
        arr[min_index] = -arr[min_index]
        k -= 1

    return sum(arr)

if __name__ == "__main__":
    arr1 = [1, 2, -3, 4, 5]
    k1 = 1
    print(maximizeSum(arr1, k1))
    
    arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20]
    k2 = 5
    print(maximizeSum(arr2, k2))

using System;

class GFG {
    static int maximizeSum(int[] arr, int k) {
        int n = arr.Length;

        while (k-- > 0) {
            int minIndex = 0;

            // Find the minimum element in the array.
            for (int i = 1; i < n; i++) {
                if (arr[i] < arr[minIndex]) {
                    minIndex = i;
                }
            }

            // Negate the minimum element.
            arr[minIndex] = -arr[minIndex];
        }

        int sum = 0;

        foreach (int value in arr) {
            sum += value;
        }

        return sum;
    }

    static void Main() {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        Console.WriteLine(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        Console.WriteLine(maximizeSum(arr2, k2));
    }
}

JavaScript

/**
 * @param {number[]} arr
 * @param {number} k
 * @returns {number}
 */
function maximizeSum(arr, k) {
    const n = arr.length;

    while (k > 0) {
        let minIndex = 0;

        // Find the minimum element in the array.
        for (let i = 1; i < n; i++) {
            if (arr[i] < arr[minIndex]) {
                minIndex = i;
            }
        }

        // Negate the minimum element.
        arr[minIndex] = -arr[minIndex];
        k--;
    }

    let sum = 0;

    for (const value of arr) {
        sum += value;
    }

    return sum;
}

// Driver Code
const arr1 = [1, 2, -3, 4, 5];
const k1 = 1;
console.log(maximizeSum(arr1, k1));

const arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20];
const k2 = 5;
console.log(maximizeSum(arr2, k2));

Output

15
68

[Expected Approach] Using Sorting and Greedy - O(n log n) Time and O(1) Space

Sort the array so that all negative elements appear first. Traverse the sorted array and negate negative elements while operations are available. Negating the most negative elements first provides the largest increase in the sum.

After processing the negative elements:

If k is even, the remaining operations can be applied in pairs without changing the final sum.
If k is odd, one element must remain negated.
To minimize the loss, negate the element having the smallest absolute value.

Finally, calculate and return the maximum sum.

Why does it work?

For a negative value x, changing it to -x increases the sum by 2 × |x|. Therefore, negating elements with larger absolute negative values first gives the maximum improvement.
If one operation remains, negating the minimum absolute value causes the smallest possible decrease.

C++

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
using namespace std;

int maximizeSum(vector<int>& arr, int k) {
    sort(arr.begin(), arr.end());

    // Negate negative elements while operations are available.
    for (int i = 0; i < arr.size() && k > 0; i++) {
        if (arr[i] < 0) {
            arr[i] = -arr[i];
            k--;
        }
    }

    int sum = 0;
    int minValue = abs(arr[0]);

    // Calculate the sum and minimum absolute value.
    for (int value : arr) {
        sum += value;
        minValue = min(minValue, abs(value));
    }

    // Negate the minimum absolute value if one odd operation remains.
    if (k % 2 == 1) {
        sum -= 2 * minValue;
    }

    return sum;
}

int main() {
    vector<int> arr1 = {1, 2, -3, 4, 5};
    int k1 = 1;
    cout << maximizeSum(arr1, k1) << endl;

    vector<int> arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
    int k2 = 5;
    cout << maximizeSum(arr2, k2) << endl;

    return 0;
}

Java

import java.util.Arrays;

class GFG {
    static int maximizeSum(int[] arr, int k) {
        Arrays.sort(arr);

        // Negate negative elements while operations are available.
        for (int i = 0; i < arr.length && k > 0; i++) {
            if (arr[i] < 0) {
                arr[i] = -arr[i];
                k--;
            }
        }

        int sum = 0;
        int minValue = Math.abs(arr[0]);

        // Calculate the sum and minimum absolute value.
        for (int value : arr) {
            sum += value;
            minValue = Math.min(minValue, Math.abs(value));
        }

        // Negate the minimum absolute value if one odd operation remains.
        if (k % 2 == 1) {
            sum -= 2 * minValue;
        }

        return sum;
    }

    public static void main(String[] args) {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        System.out.println(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        System.out.println(maximizeSum(arr2, k2));
    }
}

Python

def maximizeSum(arr, k):
    arr.sort()

    # Negate negative elements while operations are available.
    for i in range(len(arr)):
        if k == 0:
            break

        if arr[i] < 0:
            arr[i] = -arr[i]
            k -= 1

    total = 0
    min_value = abs(arr[0])

    # Calculate the sum and minimum absolute value.
    for value in arr:
        total += value
        min_value = min(min_value, abs(value))

    # Negate the minimum absolute value if one odd operation remains.
    if k % 2 == 1:
        total -= 2 * min_value

    return total

if __name__ == "__main__":
    arr1 = [1, 2, -3, 4, 5]
    k1 = 1
    print(maximizeSum(arr1, k1))
    
    arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20]
    k2 = 5
    print(maximizeSum(arr2, k2))

using System;

class GFG {
    static int maximizeSum(int[] arr, int k) {
        Array.Sort(arr);

        // Negate negative elements while operations are available.
        for (int i = 0; i < arr.Length && k > 0; i++) {
            if (arr[i] < 0) {
                arr[i] = -arr[i];
                k--;
            }
        }

        int sum = 0;
        int minValue = Math.Abs(arr[0]);

        // Calculate the sum and minimum absolute value.
        foreach (int value in arr) {
            sum += value;
            minValue = Math.Min(minValue, Math.Abs(value));
        }

        // Negate the minimum absolute value if one odd operation remains.
        if (k % 2 == 1) {
            sum -= 2 * minValue;
        }

        return sum;
    }

    static void Main() {
        int[] arr1 = {1, 2, -3, 4, 5};
        int k1 = 1;
        Console.WriteLine(maximizeSum(arr1, k1));

        int[] arr2 = {5, -2, 5, -4, 5, -12, 5, 5, 5, 20};
        int k2 = 5;
        Console.WriteLine(maximizeSum(arr2, k2));
    }
}

JavaScript

/**
 * @param {number[]} arr
 * @param {number} k
 * @returns {number}
 */
function maximizeSum(arr, k) {
    arr.sort((a, b) => a - b);

    // Negate negative elements while operations are available.
    for (let i = 0; i < arr.length && k > 0; i++) {
        if (arr[i] < 0) {
            arr[i] = -arr[i];
            k--;
        }
    }

    let sum = 0;
    let minValue = Math.abs(arr[0]);

    // Calculate the sum and minimum absolute value.
    for (const value of arr) {
        sum += value;
        minValue = Math.min(minValue, Math.abs(value));
    }

    // Negate the minimum absolute value if one odd operation remains.
    if (k % 2 === 1) {
        sum -= 2 * minValue;
    }

    return sum;
}

// Driver Code
const arr1 = [1, 2, -3, 4, 5];
const k1 = 1;
console.log(maximizeSum(arr1, k1));

const arr2 = [5, -2, 5, -4, 5, -12, 5, 5, 5, 20];
const k2 = 5;
console.log(maximizeSum(arr2, k2));

Output

15
68

Maximize Array Sum After k Negations

[Naive Approach] Using Recursion - O(n^k × n) time and O(k) space

[Better Approach] Repeatedly Negate the Minimum Element - O(n × k) Time and O(1) Space

[Expected Approach] Using Sorting and Greedy - O(n log n) Time and O(1) Space

Explore