Range Sum Query 2D - Mutable - Practice Coding Problems

Range Sum Query 2D - Mutable - Problem

Range Sum Query 2D - Mutable

You're given a 2D matrix and need to efficiently handle two types of operations:

📝 Update: Change the value of any cell in the matrix
📊 Query: Calculate the sum of all elements within a rectangular region

The challenge is to design a data structure that can handle multiple updates and queries efficiently. A naive approach would recalculate sums from scratch each time, but with smart preprocessing, we can do much better!

Example:
matrix = [[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]]

• sumRegion(2,1,4,3) returns 8 (sum of rectangle from (2,1) to (4,3))
• update(3,2,2) changes matrix[3][2] from 0 to 2
• sumRegion(2,1,4,3) now returns 10 (updated sum)

🎯 Goal: Implement the NumMatrix class with efficient update and query operations.

Input & Output

example_1.py — Basic Operations

$ Input: matrix = [[3,0,1,4,2],[5,6,3,2,1],[1,2,0,1,5],[4,1,0,1,7],[1,0,3,0,5]] Operations: sumRegion(2,1,4,3), update(3,2,2), sumRegion(2,1,4,3)

› Output: 8, null, 10

💡 Note: First query sums rectangle (2,1) to (4,3): 2+0+1+1+0+1+0+3+0 = 8. After updating (3,2) from 0 to 2, the same rectangle now sums to 10.

example_2.py — Single Cell Query

$ Input: matrix = [[1,2],[3,4]] Operations: sumRegion(0,0,0,0), update(0,0,5), sumRegion(0,0,0,0)

› Output: 1, null, 5

💡 Note: Query single cell (0,0) returns 1. After updating to 5, same query returns 5.

example_3.py — Entire Matrix Query

$ Input: matrix = [[1,2],[3,4]] Operations: sumRegion(0,0,1,1), update(1,1,10), sumRegion(0,0,1,1)

› Output: 10, null, 16

💡 Note: Entire 2x2 matrix sums to 1+2+3+4=10. After updating (1,1) from 4 to 10, sum becomes 1+2+3+10=16.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 200
-10⁵ ≤ matrix[i][j] ≤ 10⁵
0 ≤ row1 ≤ row2 < m
0 ≤ col1 ≤ col2 < n
-10⁵ ≤ val ≤ 10⁵
At most 10⁴ calls will be made to sumRegion and update

Visualization

Tap to expand

Understanding the Visualization

Building Setup

Initialize the smart building monitoring system with sensor data from each room

Real-time Updates

When occupancy changes in a room, update affects multiple monitoring stations in logarithmic cascades

Zone Queries

Building manager queries any rectangular zone using prefix sum technique with inclusion-exclusion

Efficient Response

System responds in O(log m × log n) time regardless of zone size

Key Takeaway

🎯 Key Insight: Binary Indexed Tree provides the perfect balance between update and query performance, making it ideal for real-time applications where both operations are frequent and time-critical.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 24 Apple 18

The optimal solution uses a 2D Binary Indexed Tree (Fenwick Tree) to achieve O(log m × log n) time complexity for both updates and range sum queries. While the brute force approach offers O(1) updates but O(m×n) queries, the BIT provides logarithmic performance for both operations, making it ideal for applications with frequent mixed operations.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Calculation)	O(1) update, O(m×n) query	O(m×n)	Store matrix directly, recalculate sums for each query
2D Binary Indexed Tree (Optimal)	O(log m × log n)	O(m × n)	Use 2D Fenwick Tree for O(log m × log n) updates and queries

Brute Force (Direct Calculation) — Algorithm Steps

Store the matrix as-is in a 2D array
For updates: directly change matrix[row][col] = val
For queries: iterate through all cells from (row1,col1) to (row2,col2)
Sum all values in the rectangular region

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Rectangle

Identify the rectangular region from (row1,col1) to (row2,col2)

Iterate Cells

Visit each cell in the rectangle row by row

Sum Values

Add each cell's value to the running total

Code -

solution.c — C

typedef struct {
    int** matrix;
    int rows, cols;
} NumMatrix;

NumMatrix* numMatrixCreate(int** matrix, int matrixSize, int* matrixColSize) {
    NumMatrix* obj = (NumMatrix*)malloc(sizeof(NumMatrix));
    obj->matrix = matrix;
    obj->rows = matrixSize;
    obj->cols = matrixSize > 0 ? matrixColSize[0] : 0;
    return obj;
}

void numMatrixUpdate(NumMatrix* obj, int row, int col, int val) {
    obj->matrix[row][col] = val;
}

int numMatrixSumRegion(NumMatrix* obj, int row1, int col1, int row2, int col2) {
    int total = 0;
    for (int i = row1; i <= row2; i++) {
        for (int j = col1; j <= col2; j++) {
            total += obj->matrix[i][j];
        }
    }
    return total;
}

void numMatrixFree(NumMatrix* obj) {
    free(obj);
}

// Example usage requires matrix initialization

Time & Space Complexity

Time Complexity

⏱️

O(1) update, O(m×n) query

Update is constant time, but query must examine up to all m×n cells

✓ Linear Growth

Space Complexity

O(m×n)

Only stores the original matrix

⚡ Linearithmic Space

78.5K Views

Medium-High Frequency

~25 min Avg. Time

1.8K 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 (Direct Calculation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler