Maximize Sum Of Array After K Negations

Maximize Sum Of Array After K Negations - Problem

Given an integer array nums and an integer k, modify the array in the following way: choose an index i and replace nums[i] with -nums[i].

You should apply this process exactly k times. You may choose the same index i multiple times.

Return the largest possible sum of the array after modifying it in this way.

Input & Output

Example 1 — Basic Case

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

› Output: 5

💡 Note: Choose index 1 and nums becomes [4,-2,3]. Sum is 4 + (-2) + 3 = 5, which is the maximum possible.

Example 2 — Multiple Negations

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

› Output: 6

💡 Note: Choose indices (1, 2, 2) and nums becomes [3,1,0,2]. Sum is 3 + 1 + 0 + 2 = 6.

Example 3 — All Negative

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

› Output: 4

💡 Note: Flip the two most negative: [-1,-2,-3] → [-1,-2,3] → [-1,2,3]. Sum is -1 + 2 + 3 = 4.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12

The key insight is to greedily flip the most negative numbers first to maximize the sum gain. The greedy approach sorts the array and flips negatives, then handles remaining operations optimally. Time: O(n log n), Space: O(1)

Common Approaches

✓ Frequency Count

⏱️ Time: N/A Space: N/A

Brute Force - Try All Combinations

⏱️ Time: O(n^k) Space: O(k)

Generate all possible combinations of applying k negations to different positions. For each combination, calculate the resulting sum and track the maximum. This explores every possibility but is very slow.

Greedy Approach

⏱️ Time: O(n log n) Space: O(1)

Sort the array by value and greedily flip the most negative numbers first to maximize gain. If k is odd after flipping all negatives, we may need to flip the smallest positive number.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 100000
#define MAX_VAL 100000

int isValid(int* count, int maxFreq, int length) {
    if (length == 1) return 1;
    
    int frequencies[1000];
    int freqCount = 0;
    
    for (int f = 1; f <= maxFreq; f++) {
        if (count[f] > 0) {
            frequencies[freqCount++] = f;
        }
    }
    
    // Sort frequencies
    for (int i = 0; i < freqCount - 1; i++) {
        for (int j = i + 1; j < freqCount; j++) {
            if (frequencies[i] > frequencies[j]) {
                int temp = frequencies[i];
                frequencies[i] = frequencies[j];
                frequencies[j] = temp;
            }
        }
    }
    
    if (freqCount == 1) {
        int f = frequencies[0];
        int c = count[f];
        return f == 1 || c == 1;
    }
    
    if (freqCount == 2) {
        int f1 = frequencies[0], f2 = frequencies[1];
        int c1 = count[f1], c2 = count[f2];
        
        if (f1 == 1 && c1 == 1) return 1;
        if (f2 == f1 + 1 && c2 == 1) return 1;
        if (f1 == 1 && c1 == 1 && f2 * c2 == length - 1) return 1;
        if (f2 == f1 + 1 && f1 * c1 + f2 * c2 == length) return 1;
        if (f2 == 1) return 1;
    }
    
    return 0;
}

int solution(int* nums, int n) {
    int freq[MAX_VAL + 1] = {0};
    int count[MAX_N + 1] = {0}; // count[f] = how many numbers appear f times
    int maxLen = 0;
    int maxFreq = 0;
    
    for (int i = 0; i < n; i++) {
        int num = nums[i];
        
        // Update frequency maps
        if (freq[num] > 0) {
            count[freq[num]]--;
        }
        
        freq[num]++;
        count[freq[num]]++;
        if (freq[num] > maxFreq) maxFreq = freq[num];
        
        // Check if current prefix is valid
        if (isValid(count, maxFreq, i + 1)) {
            maxLen = i + 1;
        }
    }
    
    return maxLen;
}

int main() {
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    int nums[MAX_N];
    int n = 0;
    char* ptr = strchr(line, '[') + 1;
    char* token = strtok(ptr, ",]");
    
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.3K Views

Medium Frequency

~15 min Avg. Time

856 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