Maximize Sum Of Array After K Negations - Practice Coding Problems

Maximize Sum Of Array After K Negations - Problem

You're given an integer array nums and an integer k, and your goal is to maximize the sum of the array by strategically flipping signs!

The Challenge: You must perform exactly k negation operations, where each operation lets you pick any index i and replace nums[i] with -nums[i]. You can choose the same index multiple times if needed.

Strategy Matters: The key insight is that you want to eliminate negative numbers first (since flipping them increases the sum), and if you have leftover operations, you'll want to flip the smallest absolute value an even or odd number of times depending on what maximizes the final sum.

Example: With nums = [2, -3, -1, 5, -4] and k = 2, you could flip -4 to get [2, -3, -1, 5, 4], then flip -3 to get [2, 3, -1, 5, 4] for a final sum of 13.

Input & Output

example_1.py — Basic Case

$ Input: nums = [4,2,3], k = 1

› Output: 5

💡 Note: Choose index 1 and nums becomes [4,-2,3]. The sum is 4 + (-2) + 3 = 5. Actually, we should choose index 1 to negate the smallest positive number: nums becomes [4,-2,3], sum = 5. Wait, that's wrong. We should negate index 1 (value 2): [4,-2,3] = 5. Actually the optimal is to negate the smallest value to minimize loss.

example_2.py — Multiple Negatives

$ Input: nums = [3,-1,0,2], k = 3

› Output: 6

💡 Note: Choose indices (1, 2, 2) and nums becomes [3,1,0,2]. We flip -1 to 1 (k=2 left), then 0 to 0 twice (k=0 left). Sum = 3 + 1 + 0 + 2 = 6.

example_3.py — All Negatives

$ Input: nums = [-8,3,-5,-3,-5,-2], k = 6

› Output: 22

💡 Note: We can flip all negative numbers: [-8,3,-5,-3,-5,-2] becomes [8,3,5,3,5,2]. Sum = 8 + 3 + 5 + 3 + 5 + 2 = 26. Wait, we have exactly 4 negatives and k=6, so 2 operations left. Since 2 is even, we end up with all positive values.

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ k ≤ 10⁴
-100 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Survey Your Wealth

Line up all your coins from worst debt to best asset

Eliminate Debts First

Use your magic flips on the biggest debts to turn them into assets

Handle Leftover Magic

If you have unused flips, minimize damage by flipping your smallest asset

Key Takeaway

🎯 Key Insight: The greedy approach of eliminating the most negative values first, followed by optimal handling of remaining operations, guarantees the maximum possible sum in optimal time complexity.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 Apple 5

The optimal greedy approach sorts the array and strategically flips the most negative numbers first, then handles any remaining operations by targeting the smallest absolute value. This achieves O(n log n) time complexity and maximizes the sum efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(n^k)	O(1)	Generate all possible ways to apply k negations and find the maximum sum
Greedy with Sorting (Optimal)	O(n log n)	O(1)	Sort by value, eliminate negatives greedily, handle remaining operations optimally

Brute Force (Try All Combinations) — Algorithm Steps

Generate all possible ways to choose k indices (with repetition allowed)
For each combination, apply the negations and calculate the sum
Keep track of the maximum sum found
Return the maximum sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with original array and k operations

Branch Creation

For each position, create a branch representing negating that element

Recursive Exploration

Recursively explore each branch until k operations are used

Backtracking

Undo changes and try next possibility

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int sum_array(int* arr, int n) {
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += arr[i];
    }
    return sum;
}

int backtrack(int* arr, int n, int operationsLeft) {
    if (operationsLeft == 0) {
        return sum_array(arr, n);
    }
    
    int maxSum = INT_MIN;
    for (int i = 0; i < n; i++) {
        arr[i] = -arr[i];
        int result = backtrack(arr, n, operationsLeft - 1);
        if (result > maxSum) {
            maxSum = result;
        }
        arr[i] = -arr[i]; // backtrack
    }
    
    return maxSum;
}

int largestSumAfterKNegations(int* nums, int numsSize, int k) {
    int* copy = malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        copy[i] = nums[i];
    }
    int result = backtrack(copy, numsSize, k);
    free(copy);
    return result;
}

int main() {
    printf("Implementation requires input parsing\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^k)

We have n choices for each of the k operations, leading to n^k possible combinations

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for tracking the maximum sum

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler