Zero Array Transformation III

Zero Array Transformation III - Problem

Array Greedy Sorting Heap (Priority Queue) Prefix Sum Medium

Zero Array Transformation III challenges you to find the maximum number of queries you can remove while still being able to transform an array to all zeros.

You're given an integer array nums and a 2D array queries where each queries[i] = [li, ri] represents a range operation. Each query allows you to decrement any values in the range [li, ri] by at most 1 (you can choose how much to decrement each position independently, from 0 to 1).

Your goal: Remove as many queries as possible while ensuring the remaining queries can still transform nums into a zero array (all elements equal to 0). Return the maximum number of removable queries, or -1 if it's impossible even with all queries.

Key insight: This is an optimization problem where you need to find the minimum set of queries required, then subtract from the total to get the maximum removals.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,0,2], queries = [[0,2],[1,2]]

› Output: 0

💡 Note: We need both queries to make the array zero. Query [0,2] can reduce positions 0 and 2 by 1 each (making them [1,0,1]), then query [1,2] reduces positions 1 and 2 by 1 each (making them [1,0,0]). We still need query [0,2] again to reduce position 0 to 0, but we can reuse queries. Actually, each query can be applied optimally to exactly cover what's needed.

example_2.py — Impossible Case

$ Input: nums = [1,1,1,1], queries = [[1,3]]

› Output: -1

💡 Note: The single query [1,3] can only cover positions 1, 2, and 3, but position 0 has value 1 and cannot be covered by any query. Therefore, it's impossible to make all elements zero.

example_3.py — Multiple Solutions

$ Input: nums = [1,0,1], queries = [[0,0],[2,2],[0,2]]

› Output: 2

💡 Note: We can use just query [0,2] to cover both positions 0 and 2, reducing them to 0. The other two queries [0,0] and [2,2] are redundant and can be removed. Maximum removals = 2.

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ l_i ≤ r_i < nums.length

Visualization

Tap to expand

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses binary search on the number of removable queries combined with a greedy validation strategy. We binary search from 0 to m queries that can be removed, and for each candidate, we check if the remaining queries can transform the array to zero using a greedy approach that prioritizes queries with the rightmost coverage.

Common Approaches

✓ Binary Search + Greedy (Optimal)

⏱️ Time: O(log m × (m log m + n)) Space: O(m + n)

Binary search on the number of queries we can remove. For each candidate, use a greedy approach to check if we can make the array zero with the remaining queries.

Brute Force (Try All Combinations)

⏱️ Time: O(2^m × n) Space: O(n)

Generate all possible subsets of queries and for each subset, simulate the range decrements to check if we can make all elements zero. Keep track of the smallest valid subset.

Binary Search + Greedy (Optimal) — Algorithm Steps

Binary search on the number of removable queries (0 to m)
For each candidate k, check if we can solve with m-k queries
Sort queries by right endpoint for greedy processing
Use greedy strategy: process array left to right, use rightmost available query when needed
Use max heap to efficiently select the best available queries

Visualization

Tap to expand

Step-by-Step Walkthrough

Binary Search

Search for maximum removable queries between 0 and m

Greedy Check

For each candidate, check if remaining queries can solve the problem

Query Selection

Greedily select queries that extend furthest to the right

Validation

Verify all array elements can be reduced to zero

Code -

solution.c — C

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

static int nums[100000];
static int remaining[100000];
static int to_remove[100000];
static int** queries;
static int queriesSize;

typedef struct {
    int neg_end;
    int idx;
} HeapItem;

typedef struct {
    HeapItem* items;
    int size;
    int capacity;
} MaxHeap;

void heapInit(MaxHeap* h, int capacity) {
    h->items = malloc(capacity * sizeof(HeapItem));
    h->size = 0;
    h->capacity = capacity;
}

void heapPush(MaxHeap* h, int neg_end, int idx) {
    h->items[h->size].neg_end = neg_end;
    h->items[h->size].idx = idx;
    int i = h->size++;
    while (i > 0) {
        int parent = (i - 1) / 2;
        if (h->items[parent].neg_end >= h->items[i].neg_end) break;
        HeapItem temp = h->items[parent];
        h->items[parent] = h->items[i];
        h->items[i] = temp;
        i = parent;
    }
}

HeapItem heapPop(MaxHeap* h) {
    HeapItem result = h->items[0];
    h->items[0] = h->items[--h->size];
    int i = 0;
    while (1) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int largest = i;
        if (left < h->size && h->items[left].neg_end > h->items[largest].neg_end)
            largest = left;
        if (right < h->size && h->items[right].neg_end > h->items[largest].neg_end)
            largest = right;
        if (largest == i) break;
        HeapItem temp = h->items[i];
        h->items[i] = h->items[largest];
        h->items[largest] = temp;
        i = largest;
    }
    return result;
}

typedef struct {
    int end;
    int idx;
} Event;

typedef struct {
    Event* events;
    int size;
    int capacity;
} EventList;

void eventListInit(EventList* el, int capacity) {
    el->events = malloc(capacity * sizeof(Event));
    el->size = 0;
    el->capacity = capacity;
}

void eventListAdd(EventList* el, int end, int idx) {
    el->events[el->size].end = end;
    el->events[el->size].idx = idx;
    el->size++;
}

int canMakeZero(int* nums, int numsSize, int** queries, int queriesSize) {
    int n = numsSize;
    
    // Create events for queries starting
    EventList* events = malloc(n * sizeof(EventList));
    for (int i = 0; i < n; i++) {
        eventListInit(&events[i], queriesSize);
    }
    
    for (int i = 0; i < queriesSize; i++) {
        int l = queries[i][0];
        int r = queries[i][1];
        eventListAdd(&events[l], r, i);
    }
    
    MaxHeap available;
    heapInit(&available, queriesSize * 2);
    for (int i = 0; i < n; i++) {
        remaining[i] = nums[i];
    }
    
    for (int pos = 0; pos < n; pos++) {
        // Add queries starting at this position
        for (int i = 0; i < events[pos].size; i++) {
            int end = events[pos].events[i].end;
            int query_idx = events[pos].events[i].idx;
            heapPush(&available, -end, query_idx);
        }
        
        // Remove queries that ended before this position
        HeapItem* temp = malloc(available.size * sizeof(HeapItem));
        int tempSize = 0;
        while (available.size > 0) {
            HeapItem item = heapPop(&available);
            int neg_end = item.neg_end;
            int query_idx = item.idx;
            if (-neg_end >= pos) {
                temp[tempSize++] = item;
            }
        }
        
        for (int i = 0; i < tempSize; i++) {
            heapPush(&available, temp[i].neg_end, temp[i].idx);
        }
        free(temp);
        
        // Use queries greedily to satisfy current position
        int need = remaining[pos];
        HeapItem* used_here = malloc(available.size * sizeof(HeapItem));
        int used_count = 0;
        
        while (need > 0 && available.size > 0) {
            HeapItem item = heapPop(&available);
            used_here[used_count++] = item;
            need--;
        }
        
        if (need > 0) {
            free(used_here);
            for (int i = 0; i < n; i++) {
                free(events[i].events);
            }
            free(events);
            free(available.items);
            return 0;
        }
        
        // Put back unused queries
        for (int i = 0; i < used_count; i++) {
            heapPush(&available, used_here[i].neg_end, used_here[i].idx);
        }
        free(used_here);
    }
    
    for (int i = 0; i < n; i++) {
        free(events[i].events);
    }
    free(events);
    free(available.items);
    return 1;
}

void generateCombinations(int n, int k, int start, int* current, int currentSize, int*** result, int* resultSize, int* resultCapacity) {
    if (currentSize == k) {
        if (*resultSize >= *resultCapacity) {
            *resultCapacity *= 2;
            *result = realloc(*result, (*resultCapacity) * sizeof(int*));
        }
        (*result)[*resultSize] = malloc(k * sizeof(int));
        memcpy((*result)[*resultSize], current, k * sizeof(int));
        (*resultSize)++;
        return;
    }
    
    for (int i = start; i <= n - (k - currentSize); i++) {
        current[currentSize] = i;
        generateCombinations(n, k, i + 1, current, currentSize + 1, result, resultSize, resultCapacity);
    }
}

int maxRemoval(int* nums, int numsSize, int** queries, int queriesSize) {
    int all_zero = 1;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] != 0) {
            all_zero = 0;
            break;
        }
    }
    if (all_zero) {
        return queriesSize;
    }
    
    // Check if it's possible with all queries
    if (!canMakeZero(nums, numsSize, queries, queriesSize)) {
        return -1;
    }
    
    // Binary search on number of removable queries
    int left = 0, right = queriesSize;
    int result = 0;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        
        // Try to remove mid queries - check all combinations
        int found = 0;
        if (mid == 0) {
            found = canMakeZero(nums, numsSize, queries, queriesSize);
        } else {
            // For small inputs, try all combinations
            if (queriesSize <= 20) {
                int** combinations = malloc(1000 * sizeof(int*));
                int combinationsSize = 0;
                int combinationsCapacity = 1000;
                int* current = malloc(mid * sizeof(int));
                generateCombinations(queriesSize, mid, 0, current, 0, &combinations, &combinationsSize, &combinationsCapacity);
                free(current);
                
                for (int c = 0; c < combinationsSize && !found; c++) {
                    int* remove_indices = combinations[c];
                    int** remaining_queries = malloc((queriesSize - mid) * sizeof(int*));
                    int remaining_count = 0;
                    
                    for (int i = 0; i < queriesSize; i++) {
                        int should_remove = 0;
                        for (int j = 0; j < mid; j++) {
                            if (i == remove_indices[j]) {
                                should_remove = 1;
                                break;
                            }
                        }
                        if (!should_remove) {
                            remaining_queries[remaining_count++] = queries[i];
                        }
                    }
                    
                    if (canMakeZero(nums, numsSize, remaining_queries, remaining_count)) {
                        found = 1;
                    }
                    free(remaining_queries);
                }
                
                for (int i = 0; i < combinationsSize; i++) {
                    free(combinations[i]);
                }
                free(combinations);
            } else {
                // For larger inputs, use heuristic: try removing longest queries first
                typedef struct {
                    int len;
                    int idx;
                } QueryLen;
                
                QueryLen* query_lens = malloc(queriesSize * sizeof(QueryLen));
                for (int i = 0; i < queriesSize; i++) {
                    query_lens[i].len = queries[i][1] - queries[i][0];
                    query_lens[i].idx = i;
                }
                
                // Sort by length descending
                for (int i = 0; i < queriesSize - 1; i++) {
                    for (int j = i + 1; j < queriesSize; j++) {
                        if (query_lens[i].len < query_lens[j].len) {
                            QueryLen temp = query_lens[i];
                            query_lens[i] = query_lens[j];
                            query_lens[j] = temp;
                        }
                    }
                }
                
                for (int i = 0; i < queriesSize; i++) to_remove[i] = 0;
                for (int i = 0; i < mid; i++) {
                    to_remove[query_lens[i].idx] = 1;
                }
                
                int** remaining_queries = malloc((queriesSize - mid) * sizeof(int*));
                int remaining_count = 0;
                for (int i = 0; i < queriesSize; i++) {
                    if (!to_remove[i]) {
                        remaining_queries[remaining_count++] = queries[i];
                    }
                }
                
                found = canMakeZero(nums, numsSize, remaining_queries, remaining_count);
                
                free(query_lens);
                free(remaining_queries);
            }
        }
        
        if (found) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && (*p == ' ' || *p == ',')) p++;
    
    while (*p && *p != '\n' && *p != '\0') {
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
        while (*p && (*p == ' ' || *p == ',')) p++;
    }
}

int main() {
    char nums_line[1000];
    char queries_line[2000];
    
    fgets(nums_line, sizeof(nums_line), stdin);
    fgets(queries_line, sizeof(queries_line), stdin);
    
    // Remove newlines
    nums_line[strcspn(nums_line, "\n")] = 0;
    queries_line[strcspn(queries_line, "\n")] = 0;
    
    // Parse nums
    int numsSize;
    parseArray(nums_line, nums, &numsSize);
    
    // Parse queries - handle [[0,2],[1,2]] format
    queries = malloc(100 * sizeof(int*));
    queriesSize = 0;
    
    const char* p = queries_line;
    while (*p && *p != '[') p++; // find first '['
    if (*p) p++; // skip first '['
    
    while (*p && *p != '\0') {
        // Skip whitespace and commas
        while (*p && (*p == ' ' || *p == ',' || *p == ']')) p++;
        
        // Look for inner '['
        if (*p == '[') {
            p++; // skip '['
            queries[queriesSize] = malloc(2 * sizeof(int));
            
            // Parse first number
            queries[queriesSize][0] = (int)strtol(p, (char**)&p, 10);
            
            // Skip comma
            while (*p && *p != ',') p++;
            if (*p == ',') p++;
            
            // Parse second number
            queries[queriesSize][1] = (int)strtol(p, (char**)&p, 10);
            
            // Skip to ']'
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            
            queriesSize++;
        } else {
            break;
        }
    }
    
    printf("%d\n", maxRemoval(nums, numsSize, queries, queriesSize));
    
    for (int i = 0; i < queriesSize; i++) {
        free(queries[i]);
    }
    free(queries);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log m × (m log m + n))

Binary search (log m) × (sort queries + greedy validation per iteration)

⚡ Linearithmic

Space Complexity

O(m + n)

Space for sorting queries and auxiliary data structures

⚡ 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

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler