Zero Array Transformation I

Zero Array Transformation I - Problem

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

For each queries[i]:

Select a subset of indices within the range [l_i, r_i] in nums.
Decrement the values at the selected indices by 1.

A Zero Array is an array where all elements are equal to 0.

Return true if it is possible to transform nums into a Zero Array after processing all the queries sequentially, otherwise return false.

Input & Output

Example 1 — Basic Case

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

› Output: false

💡 Note: Position 3 has value 4 but only 1 query can affect it (query [1,3]), so it cannot be reduced to 0

Example 2 — Possible Transformation

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

› Output: true

💡 Note: Single query [0,2] can decrement positions 0 and 2 once each, making array [0,0,0]

Example 3 — Edge Case

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

› Output: true

💡 Note: Array is already all zeros, no queries needed

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 12 a Amazon 8 M Microsoft 6 f Meta 4

The key insight is that each position needs sufficient coverage from overlapping query ranges to be decremented to zero. The optimal approach uses a difference array to efficiently count how many queries can affect each position, then validates if this coverage is sufficient. Time: O(n + q), Space: O(n).

Common Approaches

✓ Brute Force Simulation

⏱️ Time: O(2^(n*q)) Space: O(q)

For each query range, try all possible subsets of indices to decrement. This explores all combinations but is exponentially expensive.

Difference Array (Optimal)

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

Instead of updating ranges one by one, use difference array to mark range starts and ends, then compute prefix sums to get coverage counts efficiently.

Prefix Sum Optimization

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

Each query can decrement any subset of indices in its range. The key insight is that we need to check if each position can be decremented enough times by overlapping queries to reach zero.

Brute Force Simulation — Algorithm Steps

For each query, generate all possible subsets in range [l,r]
Apply decrements and recursively check remaining queries
Return true if any combination leads to all zeros

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Range

For each query [l,r], consider all 2^(r-l+1) subsets

Apply Decrements

Decrement selected indices by 1 in each subset

Check Result

After all queries, verify if array is all zeros

Code -

solution.c — C

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

bool backtrack(int idx, int* currentNums, int n, int queries[][2], int q) {
    if (idx == q) {
        for (int i = 0; i < n; i++) {
            if (currentNums[i] != 0) return false;
        }
        return true;
    }
    
    int l = queries[idx][0], r = queries[idx][1];
    // Try all possible subsets in range [l, r]
    for (int mask = 0; mask < (1 << (r - l + 1)); mask++) {
        int* tempNums = malloc(n * sizeof(int));
        memcpy(tempNums, currentNums, n * sizeof(int));
        for (int i = 0; i <= r - l; i++) {
            if (mask & (1 << i)) {
                tempNums[l + i]--;
            }
        }
        if (backtrack(idx + 1, tempNums, n, queries, q)) {
            free(tempNums);
            return true;
        }
        free(tempNums);
    }
    return false;
}

bool solution(int* nums, int n, int queries[][2], int q) {
    int* numsCopy = malloc(n * sizeof(int));
    memcpy(numsCopy, nums, n * sizeof(int));
    bool result = backtrack(0, numsCopy, n, queries, q);
    free(numsCopy);
    return result;
}

int main() {
    // Simple input parsing for demo
    int nums[] = {2, 1, 3, 4};
    int queries[][2] = {{1, 2}, {1, 3}, {0, 1}};
    bool result = solution(nums, 4, queries, 3);
    printf(result ? "true\n" : "false\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^(n*q))

Each query can choose from 2^range_size subsets, with q queries

✓ Linear Growth

Space Complexity

O(q)

Recursion stack depth up to number of queries

⚡ Linearithmic Space

9.0K Views

Medium Frequency

~15 min Avg. Time

234 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 Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler