Subrectangle Queries - Practice Coding Problems

Subrectangle Queries - Problem

Imagine you're building a dynamic matrix editor that needs to efficiently handle two types of operations: bulk updates and single-cell queries. This is exactly what the SubrectangleQueries class does!

Your task is to implement a class that manages a 2D matrix and supports:

updateSubrectangle(row1, col1, row2, col2, newValue): Update all cells in the rectangular region from top-left corner (row1, col1) to bottom-right corner (row2, col2) with the same value.
getValue(row, col): Retrieve the current value at position (row, col).

Example:

matrix = [[1,2,1],[4,3,4]]
updateSubrectangle(0, 0, 1, 2, 5) → [[5,5,5],[5,5,5]]
getValue(0, 2) → 5

The challenge is to balance update efficiency vs query efficiency based on the expected usage patterns!

Input & Output

example_1.py — Basic Operations

$ Input: SubrectangleQueries([[1,2,1],[4,3,4]]) updateSubrectangle(0, 0, 1, 2, 5) getValue(0, 2) getValue(1, 1) updateSubrectangle(1, 0, 1, 2, 10) getValue(1, 0)

› Output: [null, null, 5, 5, null, 10]

💡 Note: Initially matrix is [[1,2,1],[4,3,4]]. After first update, all cells become 5. After second update, bottom row becomes [10,10,10].

example_2.py — Single Cell Update

$ Input: SubrectangleQueries([[1,1,1],[2,2,2],[3,3,3]]) updateSubrectangle(0, 0, 0, 0, 100) getValue(0, 0) getValue(0, 1)

› Output: [null, null, 100, 1]

💡 Note: Only the top-left corner (0,0) is updated to 100. Other cells retain original values.

example_3.py — Overlapping Updates

$ Input: SubrectangleQueries([[1,2],[3,4]]) updateSubrectangle(0, 0, 1, 1, 5) updateSubrectangle(0, 0, 0, 1, 10) getValue(0, 0) getValue(1, 0)

› Output: [null, null, null, 10, 5]

💡 Note: First update makes all cells 5. Second update overwrites top row to 10. getValue(0,0) returns 10 from most recent update, getValue(1,0) returns 5 from first update.

Constraints

1 ≤ rows, cols ≤ 100
1 ≤ rectangle[i][j] ≤ 10⁹
0 ≤ row1 ≤ row2 < rows
0 ≤ col1 ≤ col2 < cols
1 ≤ newValue ≤ 10⁹
At most 500 calls will be made to updateSubrectangle and getValue

Visualization

Tap to expand

Understanding the Visualization

Direct Painting

Paint each cell immediately - slow to paint, fast to see color

Paint Instructions

Write down paint instructions - fast to write, need to check instructions when viewing

Trade-off Analysis

Choose strategy based on whether you paint more or look more often

Key Takeaway

🎯 Key Insight: The optimal approach depends on your access pattern. With at most 500 total operations, the lazy approach often wins due to its O(1) update time, making it ideal for scenarios with bulk updates followed by targeted queries.

Asked in

G Google 12 a Amazon 8 ⊞ Microsoft 6 Apple 4

This problem offers a classic trade-off between update and query efficiency. The brute force approach updates the matrix directly (O(r×c) update, O(1) query), while the optimal lazy approach stores updates as operations (O(1) update, O(k) query). Choose based on your usage pattern: direct updates for query-heavy workloads, lazy updates for update-heavy scenarios.

Common Approaches

Approach	Time	Space	Notes
✓ Lazy Update with History Stack (Optimal)	O(1) per update, O(k) per query	O(m×n + u)	Store update operations in a list and apply them lazily during queries
Direct Matrix Updates (Brute Force)	O(r×c) per update, O(1) per query	O(m×n)	Directly update all cells in the subrectangle for each update operation

Lazy Update with History Stack (Optimal) — Algorithm Steps

Keep the original matrix unchanged
Store each update operation as (row1, col1, row2, col2, newValue)
For updateSubrectangle: append the operation to history list in O(1)
For getValue: iterate through history from newest to oldest
Return the value from the first update that contains (row, col), or original value

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Update

Add update operation to history stack in O(1)

Query Cell

Check history from newest to oldest

Find Match

Return value from first update that covers the cell

Fallback

If no update covers cell, return original value

Code -

solution.c — C

typedef struct {
    int** matrix;
    int rows, cols;
    int** updates;
    int updateCount;
    int updateCapacity;
} SubrectangleQueries;

SubrectangleQueries* subrectangleQueriesCreate(int** rectangle, int rectangleSize, int* rectangleColSize) {
    SubrectangleQueries* obj = (SubrectangleQueries*)malloc(sizeof(SubrectangleQueries));
    obj->matrix = rectangle;
    obj->rows = rectangleSize;
    obj->cols = rectangleColSize[0];
    obj->updateCapacity = 100;
    obj->updates = (int**)malloc(obj->updateCapacity * sizeof(int*));
    obj->updateCount = 0;
    return obj;
}

void subrectangleQueriesUpdateSubrectangle(SubrectangleQueries* obj, int row1, int col1, int row2, int col2, int newValue) {
    if (obj->updateCount >= obj->updateCapacity) {
        obj->updateCapacity *= 2;
        obj->updates = (int**)realloc(obj->updates, obj->updateCapacity * sizeof(int*));
    }
    obj->updates[obj->updateCount] = (int*)malloc(5 * sizeof(int));
    obj->updates[obj->updateCount][0] = row1;
    obj->updates[obj->updateCount][1] = col1;
    obj->updates[obj->updateCount][2] = row2;
    obj->updates[obj->updateCount][3] = col2;
    obj->updates[obj->updateCount][4] = newValue;
    obj->updateCount++;
}

int subrectangleQueriesGetValue(SubrectangleQueries* obj, int row, int col) {
    for (int i = obj->updateCount - 1; i >= 0; i--) {
        int* update = obj->updates[i];
        if (update[0] <= row && row <= update[2] && update[1] <= col && col <= update[3]) {
            return update[4];
        }
    }
    return obj->matrix[row][col];
}

Time & Space Complexity

Time Complexity

⏱️

O(1) per update, O(k) per query

Updates are O(1) to add to list. Queries are O(k) where k is number of updates that might affect the cell

✓ Linear Growth

Space Complexity

O(m×n + u)

Original matrix plus u update operations stored

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Lazy Update with History Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler