Zero Array Transformation III - Practice Coding Problems

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.

Visualization

Tap to expand

Understanding the Visualization

Analyze Coverage

Each array position needs a certain amount of paint coverage

Sort Rollers

Sort paint rollers by their rightmost coverage for greedy selection

Binary Search

Binary search on how many rollers we can remove while still covering all graffiti

Greedy Validation

For each candidate, greedily select rollers that extend furthest right

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy validation gives us the optimal O(log m × m log m) solution

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

Constraints

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

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

Approach	Time	Space	Notes
✓ Binary Search + Greedy (Optimal)	O(log m × (m log m + n))	O(m + n)	Binary search on the answer with greedy validation
Brute Force (Try All Combinations)	O(2^m × n)	O(n)	Try all possible subsets of queries to find the minimum required set

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>

int compare(const void *a, const void *b) {
    int *ia = (int *)a;
    int *ib = (int *)b;
    return ia[1] - ib[1];
}

int canSolve(int* nums, int numsSize, int** queries, int queriesSize, int k) {
    if (k == 0) {
        for (int i = 0; i < numsSize; i++) {
            if (nums[i] != 0) return 0;
        }
        return 1;
    }
    
    // Simplified greedy approach
    int* numsCopy = (int*)malloc(numsSize * sizeof(int));
    memcpy(numsCopy, nums, numsSize * sizeof(int));
    
    int used = 0;
    for (int i = 0; i < numsSize; i++) {
        for (int j = 0; j < queriesSize && numsCopy[i] > 0; j++) {
            if (queries[j][0] <= i && queries[j][1] >= i) {
                numsCopy[i]--;
                used++;
                if (used > k) {
                    free(numsCopy);
                    return 0;
                }
            }
        }
        if (numsCopy[i] > 0) {
            free(numsCopy);
            return 0;
        }
    }
    
    free(numsCopy);
    return 1;
}

int maxRemoval(int* nums, int numsSize, int** queries, int queriesSize) {
    int left = 0, right = queriesSize;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canSolve(nums, numsSize, queries, queriesSize, queriesSize - mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {2, 0, 2};
    int* queryData[] = {(int[]){0, 2}, (int[]){1, 2}};
    printf("%d\n", maxRemoval(nums, 3, queryData, 2));
    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

Constraints

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

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search + Greedy (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler