Make the Prefix Sum Non-negative - Practice Coding Problems

Make the Prefix Sum Non-negative - Problem

Make the Prefix Sum Non-negative

You're given a 0-indexed integer array nums that may contain both positive and negative numbers. Your goal is to rearrange the array by moving elements to the end so that all prefix sums become non-negative.

📊 What's a prefix sum? The prefix sum at index i is the sum of all elements from index 0 to i (inclusive).

🔄 Available Operation: Pick any element from nums and move it to the end of the array. You can perform this operation any number of times.

🎯 Goal: Find the minimum number of operations needed to ensure that no prefix sum in the resulting array is negative.

Example: If nums = [2, -3, 1], the initial prefix sums are [2, -1, 0]. Since the second prefix sum is negative, we need to rearrange the array!

Input & Output

example_1.py — Basic Case

$ Input: [2, 3, -5, 4]

› Output: 0

💡 Note: The prefix sums are [2, 5, 0, 4]. All prefix sums are non-negative, so no operations are needed.

example_2.py — Need Rearrangement

$ Input: [3, -5, 4]

› Output: 1

💡 Note: Initial prefix sums: [3, -2, 2]. The second prefix sum is negative. Move -5 to end: [3, 4, -5] gives prefix sums [3, 7, 2]. One operation needed.

example_3.py — Multiple Negatives

$ Input: [1, -3, 2, -4, 5]

› Output: 2

💡 Note: Initial prefix sums: [1, -2, 0, -4, 1]. Both -3 and -4 cause negative prefix sums. We need to move both to the end, requiring 2 operations.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
It is guaranteed that a solution exists (sum of all elements ≥ 0)

Visualization

Tap to expand

Understanding the Visualization

Monitor Water Level

Keep track of current water level (running sum)

Queue Drain Operations

When we encounter drains (negatives), remember them

Delay Largest Drains

If water level goes negative, delay the biggest drain until later

Count Delays

Number of delayed operations is our answer

Key Takeaway

🎯 Key Insight: Only delay operations that would cause the water level to go negative, and always delay the most negative ones first!

Asked in

G Google 45 a Amazon 38 f Meta 28 ⊞ Microsoft 22

The optimal solution uses a greedy approach with min-heap. As we traverse the array, we maintain a running sum and store negative elements in a min-heap. When the running sum becomes negative, we delay the most negative element we've seen so far by removing it from the heap. This ensures we make the minimum number of operations while keeping all prefix sums non-negative.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy with Min-Heap (Optimal)	O(n log n)	O(n)	Use greedy approach with priority queue to delay most negative elements

Greedy with Min-Heap (Optimal) — Algorithm Steps

Initialize running sum and min-heap for negative elements
For each element, add it to running sum
If element is negative, add to min-heap
If running sum becomes negative, remove most negative element from heap
Count operations as number of elements removed from heap
Process remaining heap elements at the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Elements

Add each element to running sum and negative elements to heap

Detect Negative Sum

When running sum becomes negative, we need to delay an element

Delay Most Negative

Remove the most negative element from heap and subtract from sum

Count Operations

Each heap removal represents moving an element to the end

Code -

solution.c — C

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

typedef struct {
    int* data;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = malloc(sizeof(MinHeap));
    heap->data = malloc(capacity * sizeof(int));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int index) {
    int parent = (index - 1) / 2;
    if (index > 0 && heap->data[index] < heap->data[parent]) {
        int temp = heap->data[index];
        heap->data[index] = heap->data[parent];
        heap->data[parent] = temp;
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MinHeap* heap, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < heap->size && heap->data[left] < heap->data[smallest])
        smallest = left;
    if (right < heap->size && heap->data[right] < heap->data[smallest])
        smallest = right;
    
    if (smallest != index) {
        int temp = heap->data[index];
        heap->data[index] = heap->data[smallest];
        heap->data[smallest] = temp;
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, int value) {
    heap->data[heap->size] = value;
    heapifyUp(heap, heap->size);
    heap->size++;
}

int pop(MinHeap* heap) {
    int min = heap->data[0];
    heap->data[0] = heap->data[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

int minimumOperations(int* nums, int n) {
    int operations = 0;
    long long runningSum = 0;
    MinHeap* minHeap = createHeap(n);
    
    for (int i = 0; i < n; i++) {
        runningSum += nums[i];
        
        if (nums[i] < 0) {
            push(minHeap, nums[i]);
        }
        
        if (runningSum < 0 && minHeap->size > 0) {
            int mostNegative = pop(minHeap);
            runningSum -= mostNegative;
            operations++;
        }
    }
    
    free(minHeap->data);
    free(minHeap);
    return operations;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int n = 0;
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    printf("%d\n", minimumOperations(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each element is added/removed from heap at most once, heap operations take O(log n)

⚡ Linearithmic

Space Complexity

O(n)

Min-heap can store up to n negative elements in worst case

⚡ Linearithmic Space

43.7K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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

Greedy with Min-Heap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler