Zero Array Transformation IV

Zero Array Transformation IV - Problem

You are given an integer array nums of length n and a 2D array queries, where queries[i] = [l_i, r_i, val_i].

Each queries[i] represents the following action on nums:

Select a subset of indices in the range [l_i, r_i] from nums.
Decrement the value at each selected index by exactly val_i.

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],[1,1,3]]

› Output: 2

💡 Note: After applying first 2 queries: query [0,2,1] reduces range [0,2] by 1, query [1,2,1] reduces range [1,2] by 1. Total reductions: [1,2,2] which can make [2,1,3] → [0,0,0]

Example 2 — Impossible Case

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

› Output: -1

💡 Note: Even using all queries, maximum reductions are [1,2,1] which cannot reduce [5,2,4] to zero since 1 < 5

Example 3 — Zero Queries Needed

$ 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 ≤ l_i ≤ r_i < nums.length
1 ≤ val_i ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 35 M Microsoft 28 a Amazon 22

The optimal approach uses binary search on the answer combined with difference arrays for efficient range updates. For each candidate k, we use a difference array to apply the first k queries in O(n+k) time, then check if the resulting reductions can zero out all elements. Time: O(log q × (n + q)), Space: O(n)

Common Approaches

✓ Binary Search on Answer

⏱️ Time: O(log q × n × q) Space: O(n)

Use binary search to find the minimum k. For each candidate k, check if applying first k queries can make array zero using greedy strategy.

Brute Force - Try Each k

⏱️ Time: O(q × n × q) Space: O(n)

For each possible k, simulate applying the first k queries and check if all elements become zero or negative. Return the first k that works.

Optimized Greedy with Difference Array

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

For each candidate k, use difference array technique to efficiently apply all range updates, then check if the accumulated reductions can make all elements zero.

Binary Search on Answer — Algorithm Steps

Binary search on k from 0 to queries.length
For each k, simulate applying first k queries
Use greedy approach to maximize reduction

Visualization

Tap to expand

Step-by-Step Walkthrough

Search Space

k can be from 0 to queries.length

Check Middle

Test if mid value works

Narrow Range

Eliminate half of search space

Code -

solution.c — C

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

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

void parseQueries(const char* str, int queries[][3], int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '[') p++;
        if (*p == ']' || *p == '\0') break;
        
        queries[*size][0] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        queries[*size][1] = (int)strtol(p, (char**)&p, 10);
        while (*p == ' ' || *p == ',') p++;
        queries[*size][2] = (int)strtol(p, (char**)&p, 10);
        
        while (*p && *p != ']') p++;
        if (*p == ']') p++;
        
        (*size)++;
    }
}

int canMakeZero(int* nums, int numsSize, int queries[][3], int k) {
    int* temp = (int*)malloc(numsSize * sizeof(int));
    for (int i = 0; i < numsSize; i++) {
        temp[i] = nums[i];
    }
    
    for (int i = 0; i < k; i++) {
        int l = queries[i][0];
        int r = queries[i][1];
        int val = queries[i][2];
        for (int j = l; j <= r; j++) {
            if (temp[j] > 0) {
                int newVal = temp[j] - val;
                temp[j] = newVal > 0 ? newVal : 0;
            }
        }
    }
    
    for (int i = 0; i < numsSize; i++) {
        if (temp[i] != 0) {
            free(temp);
            return 0;
        }
    }
    
    free(temp);
    return 1;
}

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

int main() {
    char line1[1000], line2[2000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int nums[1000];
    int numsSize;
    parseArray(line1, nums, &numsSize);
    
    int queries[1000][3];
    int queriesSize;
    parseQueries(line2, queries, &queriesSize);
    
    int result = solution(nums, numsSize, queries, queriesSize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log q × n × q)

Binary search (log q) iterations, each checking k queries on n elements

✓ Linear Growth

Space Complexity

O(n)

Temporary array for simulation

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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 on Answer — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler