Zero Array Transformation II - Practice Coding Problems

Zero Array Transformation II - Problem

Zero Array Transformation II is a fascinating optimization problem that challenges your understanding of range operations and binary search techniques.

You are given an integer array nums of length n and a 2D array queries where queries[i] = [li, ri, vali]. Each query represents a range decrement operation: you can decrement each element in the range [li, ri] by at most vali. The key insight is that you have flexibility - for each index in the range, you can choose how much to decrement (from 0 up to vali).

Your goal is to find the minimum number of queries needed to transform nums into a Zero Array (all elements equal to 0). If it's impossible even with all queries, return -1.

Example: If nums = [2,0,2] and queries = [[0,2,1],[0,2,1],[0,0,1]], you need at least 2 queries to zero out the array.

Input & Output

example_1.py — Basic case

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

› Output: 2

💡 Note: After applying the first 2 queries, we can decrement nums[0] by 2 (1+1), nums[1] by 0 (already 0), and nums[2] by 2 (1+1), making all elements zero.

example_2.py — Impossible case

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

› Output: -1

💡 Note: Even using all queries, we can't zero out nums[0] which equals 4, but only query [0,2,1] affects it, providing at most 1 decrement.

example_3.py — Single query sufficient

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

› Output: 1

💡 Note: The first query allows us to decrement each element in range [0,3] by up to 1, which is exactly what we need to zero out the array.

Visualization

Tap to expand

Understanding the Visualization

Initial State

Array represents debts that need to be paid off (reduced to zero)

Apply Queries

Each query is like a payment voucher that can reduce values in a range

Binary Search

Find minimum number of vouchers needed using binary search

Validation

Use difference arrays to efficiently check if k vouchers suffice

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with difference arrays provides an optimal O(n log m) solution for finding the minimum queries needed to zero out the array.

Time & Space Complexity

Time Complexity

⏱️

O(n log m)

Binary search takes O(log m) iterations, each validation takes O(n + m) time

⚡ Linearithmic

Space Complexity

O(n)

We need O(n) space for difference array and available decrements array

⚡ Linearithmic Space

Constraints

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

Asked in

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

The optimal approach uses binary search on the answer combined with difference arrays for efficient range updates. Key insight: instead of trying k=1,2,3... linearly, we binary search to find the minimum k in O(n log m) time. For each candidate k, we use difference arrays to simulate applying the first k queries in O(n+k) time, then check feasibility.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search + Difference Array (Optimal)	O(n log m)	O(n)	Binary search on the answer k, using difference arrays for efficient validation
Brute Force (Linear Search)	O(m * n)	O(n)	Try k=1,2,3... until we find the minimum k that works

Binary Search + Difference Array (Optimal) — Algorithm Steps

Set binary search bounds: left=1, right=queries.length
For each mid value, check if first mid queries can zero the array
Use difference array to efficiently apply range updates
Convert difference array to prefix sums to get available decrements
Check if available[i] >= nums[i] for all i
Adjust binary search bounds based on feasibility
Return the minimum feasible k

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Set left=1, right=m (total queries)

Check Mid

Test mid=(left+right)/2 using difference arrays

Narrow Search

If feasible, search left half; otherwise right half

Found Answer

Binary search converges to minimum k

Code -

solution.c — C

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

bool canZero(int* nums, int numsSize, int queries[][3], int queriesSize, int k) {
    int* diff = (int*)calloc(numsSize + 1, sizeof(int));
    
    // Apply first k queries to difference array
    for (int i = 0; i < k; i++) {
        int l = queries[i][0], r = queries[i][1], val = queries[i][2];
        diff[l] += val;
        diff[r + 1] -= val;
    }
    
    // Convert difference array to actual decrements available
    int* available = (int*)calloc(numsSize, sizeof(int));
    int currSum = 0;
    for (int i = 0; i < numsSize; i++) {
        currSum += diff[i];
        available[i] = currSum;
    }
    
    // Check if we can zero out the array
    bool result = true;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > available[i]) {
            result = false;
            break;
        }
    }
    
    free(diff);
    free(available);
    return result;
}

int minZeroArray(int* nums, int numsSize, int queries[][3], int queriesSize) {
    int left = 1, right = queriesSize;
    int result = -1;
    
    while (left <= right) {
        int mid = (left + right) / 2;
        if (canZero(nums, numsSize, queries, queriesSize, mid)) {
            result = mid;
            right = mid - 1;  // Try to find smaller k
        } else {
            left = mid + 1;   // Need more queries
        }
    }
    
    return result;
}

int main() {
    int nums[] = {2, 0, 2};
    int queries[][3] = {{0,2,1},{0,2,1},{0,0,1}};
    printf("%d\n", minZeroArray(nums, 3, queries, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log m)

Binary search takes O(log m) iterations, each validation takes O(n + m) time

⚡ Linearithmic

Space Complexity

O(n)

We need O(n) space for difference array and available decrements array

⚡ Linearithmic Space

Constraints

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

25.6K Views

Medium Frequency

~25 min Avg. Time

847 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 + Difference Array (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler