Subrectangle Queries

Subrectangle Queries - Problem

Implement the class SubrectangleQueries which receives a rows x cols rectangle as a matrix of integers in the constructor and supports two methods:

1. updateSubrectangle(int row1, int col1, int row2, int col2, int newValue)

Updates all values with newValue in the subrectangle whose upper left coordinate is (row1,col1) and bottom right coordinate is (row2,col2).

2. getValue(int row, int col)

Returns the current value of the coordinate (row,col) from the rectangle.

Input & Output

Example 1 — Basic Operations

$ Input: [["SubrectangleQueries",[[1,2,1],[4,3,4],[3,2,1]]],["getValue",[0,2]],["updateSubrectangle",[0,0,2,2,5]],["getValue",[0,2]],["getValue",[2,1]]]

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

💡 Note: Initialize with matrix [[1,2,1],[4,3,4],[3,2,1]], getValue(0,2) returns 1, update subrectangle to 5, getValue(0,2) now returns 5, getValue(2,1) returns 5

Example 2 — Multiple Updates

$ Input: [["SubrectangleQueries",[[1,1,1],[2,2,2],[3,3,3]]],["updateSubrectangle",[0,0,1,1,10]],["getValue",[0,0]],["updateSubrectangle",[1,1,2,2,20]],["getValue",[1,1]]]

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

💡 Note: First update sets top-left 2x2 to 10, second update overlaps and sets bottom-right 2x2 to 20

Example 3 — Edge Case Single Cell

$ Input: [["SubrectangleQueries",[[5]]],["getValue",[0,0]],["updateSubrectangle",[0,0,0,0,3]],["getValue",[0,0]]]

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

💡 Note: Single cell matrix, getValue returns 5, update single cell to 3, getValue returns 3

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is that we can either update the matrix directly (simple but slow for large updates) or store update history and check recent updates first (faster for frequent updates). Best approach depends on the update/query ratio. Update history tracking is optimal when updates are frequent: Time: O(U) per query, Space: O(R×C + U).

Common Approaches

Approach	Time	Space	Notes
✓ Update History Tracking	O(U)	O(R×C + U)	Store update operations and check recent updates during getValue
Direct Matrix Updates	O(R×C)	O(R×C)	Directly update all cells in the subrectangle for each update operation

Update History Tracking — Algorithm Steps

Initialize original matrix and empty update history
For updateSubrectangle: append operation to history list
For getValue: check history in reverse order, return first matching update or original value

Visualization

Tap to expand

Step-by-Step Walkthrough

Store Update

Add update operation to history list

Query Check

Check recent updates in reverse order

Return Value

Return first matching update or original value

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

typedef struct {
    int row1, col1, row2, col2, newValue;
} Update;

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

SubrectangleQueries* subrectangleQueriesCreate(int** rectangle, int rectangleSize, int* rectangleColSize) {
    SubrectangleQueries* obj = (SubrectangleQueries*)malloc(sizeof(SubrectangleQueries));
    obj->rows = rectangleSize;
    obj->cols = rectangleColSize[0];
    obj->matrix = rectangle;
    obj->updateCount = 0;
    obj->updateCapacity = 100;
    obj->updates = (Update*)malloc(obj->updateCapacity * sizeof(Update));
    
    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 = (Update*)realloc(obj->updates, obj->updateCapacity * sizeof(Update));
    }
    
    obj->updates[obj->updateCount].row1 = row1;
    obj->updates[obj->updateCount].col1 = col1;
    obj->updates[obj->updateCount].row2 = row2;
    obj->updates[obj->updateCount].col2 = col2;
    obj->updates[obj->updateCount].newValue = newValue;
    obj->updateCount++;
}

int subrectangleQueriesGetValue(SubrectangleQueries* obj, int row, int col) {
    // Check updates in reverse order (most recent first)
    for (int i = obj->updateCount - 1; i >= 0; i--) {
        Update* update = &obj->updates[i];
        if (update->row1 <= row && row <= update->row2 && update->col1 <= col && col <= update->col2) {
            return update->newValue;
        }
    }
    return obj->matrix[row][col];
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    cJSON* operations = cJSON_Parse(line);
    cJSON* results = cJSON_CreateArray();
    SubrectangleQueries* obj = NULL;
    
    int size = cJSON_GetArraySize(operations);
    for (int i = 0; i < size; i++) {
        cJSON* op = cJSON_GetArrayItem(operations, i);
        cJSON* method = cJSON_GetArrayItem(op, 0);
        
        if (strcmp(method->valuestring, "SubrectangleQueries") == 0) {
            cJSON* rectJson = cJSON_GetArrayItem(op, 1);
            int rows = cJSON_GetArraySize(rectJson);
            int** rect = (int**)malloc(rows * sizeof(int*));
            int* colSizes = (int*)malloc(rows * sizeof(int));
            
            for (int r = 0; r < rows; r++) {
                cJSON* row = cJSON_GetArrayItem(rectJson, r);
                int cols = cJSON_GetArraySize(row);
                colSizes[r] = cols;
                rect[r] = (int*)malloc(cols * sizeof(int));
                for (int c = 0; c < cols; c++) {
                    rect[r][c] = cJSON_GetArrayItem(row, c)->valueint;
                }
            }
            
            obj = subrectangleQueriesCreate(rect, rows, colSizes);
            cJSON_AddItemToArray(results, cJSON_CreateNull());
        } else if (strcmp(method->valuestring, "updateSubrectangle") == 0) {
            int row1 = cJSON_GetArrayItem(op, 1)->valueint;
            int col1 = cJSON_GetArrayItem(op, 2)->valueint;
            int row2 = cJSON_GetArrayItem(op, 3)->valueint;
            int col2 = cJSON_GetArrayItem(op, 4)->valueint;
            int newValue = cJSON_GetArrayItem(op, 5)->valueint;
            subrectangleQueriesUpdateSubrectangle(obj, row1, col1, row2, col2, newValue);
            cJSON_AddItemToArray(results, cJSON_CreateNull());
        } else if (strcmp(method->valuestring, "getValue") == 0) {
            int row = cJSON_GetArrayItem(op, 1)->valueint;
            int col = cJSON_GetArrayItem(op, 2)->valueint;
            int result = subrectangleQueriesGetValue(obj, row, col);
            cJSON_AddItemToArray(results, cJSON_CreateNumber(result));
        }
    }
    
    char* output = cJSON_Print(results);
    printf("%s\n", output);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(U)

Each getValue operation checks at most U update operations in the history

✓ Linear Growth

Space Complexity

O(R×C + U)

Store original matrix R×C plus U update operations in history

✓ Linear Space

25.3K 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

Update History Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler