Zero Array Transformation II - Practice Coding Problems

Zero Array Transformation II - Problem

You are given an integer array nums of length n and a 2D array queries where queries[i] = [li, ri, vali].

Each queries[i] represents the following action on nums: Decrement the value at each index in the range [li, ri] in nums by at most vali. The amount by which each value is decremented can be chosen independently for each index.

A Zero Array is an array with all its elements equal to 0.

Return the minimum possible non-negative value of k, such that after processing the first k queries in sequence, nums becomes a Zero Array. If no such k exists, return -1.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: With k=2 queries: first query decrements range [0,2] by up to 1 each, second query decrements range [1,2] by up to 1 each. Total possible decrements: [1,2,2], which covers nums=[2,1,3]

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Even with all queries, max decrements are [1,3,3,2]. Position 0 needs 4 decrements but only gets 1, so impossible

Example 3 — Already Zero

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

› Output: 0

💡 Note: Array is already all zeros, so k=0 queries needed

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁶
1 ≤ queries.length ≤ 10⁵
queries[i].length = 3
0 ≤ li ≤ ri < nums.length
1 ≤ vali ≤ 10⁶

Visualization

Tap to expand

Understanding the Visualization

Input

Array nums and queries with [left, right, value] ranges

Process

Apply first k queries to get total possible decrements

Check

Verify if decrements ≥ original values for all positions

Key Takeaway

🎯 Key Insight: Binary search on k combined with difference arrays for O(n log m) efficiency

Asked in

G Google 15 M Microsoft 12 A Amazon 8

The key insight is to use binary search on the answer space combined with difference arrays for efficient range updates. The optimal approach uses binary search to find the minimum k in O(log m) iterations, with each iteration taking O(n) time to simulate queries using difference arrays. Time: O(n × log m), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Linear Search	O(m × n)	O(n)	Try each possible k from 0 to queries.length until we find one that works
Binary Search on Answer	O(n × log m)	O(n)	Binary search on the value of k, checking if k queries are sufficient

Brute Force Linear Search — Algorithm Steps

Try k = 0, 1, 2, ..., queries.length
For each k, apply first k queries using difference array
Check if sum of decrements ≥ original value for each position
Return first k that works, or -1 if none work

Visualization

Tap to expand

Step-by-Step Walkthrough

Try k=0

No queries applied, check if already zero

Try k=1

Apply first query, check if sufficient

Continue

Keep trying until all elements can reach zero

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize) {
    // Try each possible k
    for (int k = 0; k <= queriesSize; k++) {
        // Apply first k queries using difference array
        long long* diff = (long long*)calloc(numsSize + 1, sizeof(long long));
        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
        long long* decrements = (long long*)malloc(numsSize * sizeof(long long));
        long long currSum = 0;
        for (int i = 0; i < numsSize; i++) {
            currSum += diff[i];
            decrements[i] = currSum;
        }
        
        // Check if all elements can be reduced to zero
        int canZero = 1;
        for (int i = 0; i < numsSize; i++) {
            if (decrements[i] < nums[i]) {
                canZero = 0;
                break;
            }
        }
        
        free(diff);
        free(decrements);
        
        if (canZero) {
            return k;
        }
    }
    
    return -1;
}

int main() {
    // Parse inputs manually
    // Call solution and print result
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

Try m possible values of k, each taking O(n) time to simulate

✓ Linear Growth

Space Complexity

O(n)

Difference array to track range updates

⚡ Linearithmic Space

3.2K Views

Medium Frequency

~25 min Avg. Time

89 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

Brute Force Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler