Range Sum Query 2D

Range Sum Query 2D - Mutable - Problem

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

1. Update Operation: Change the value of any cell in the matrix

2. Range Sum Query: Calculate the sum of all elements within a rectangular region defined by upper-left corner (row1, col1) and lower-right corner (row2, col2)

Implement the NumMatrix class with these methods:

NumMatrix(int[][] matrix) - Initialize with the given matrix
void update(int row, int col, int val) - Update matrix[row][col] to val
int sumRegion(int row1, int col1, int row2, int col2) - Return sum of rectangle region

Note: The rectangle region is inclusive of boundaries.

Input & Output

Example 1 — 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,10]

💡 Note: First sumRegion(2,1,4,3) returns sum of rectangle from (2,1) to (4,3) = 2+0+1+1+0+1+0+3+0 = 8. After update(3,2,2), matrix[3][2] changes to 2. Second sumRegion returns updated sum = 10.

Example 2 — Single Cell Query

$ Input: matrix = [[1]], operations = [["sumRegion",0,0,0,0],["update",0,0,5],["sumRegion",0,0,0,0]]

› Output: [1,5]

💡 Note: Initial single cell has value 1. After updating to 5, the query returns 5.

Example 3 — Multiple Updates

$ Input: matrix = [[1,2],[3,4]], operations = [["update",0,0,10],["update",1,1,20],["sumRegion",0,0,1,1]]

› Output: [36]

💡 Note: After updates: matrix becomes [[10,2],[3,20]]. Sum of entire matrix: 10+2+3+20 = 36.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32 F Facebook 28 A Apple 22

The 2D Range Sum Query with Updates problem requires efficient handling of both updates and range queries. The key insight is using a 2D Binary Indexed Tree (Fenwick Tree) to achieve O(log m × log n) complexity for both operations. While brute force gives O(1) updates but O(m×n) queries, and prefix sums give O(1) queries but O(m×n) updates, the BIT provides balanced O(log m × log n) performance for both. Best approach: 2D Binary Indexed Tree. Time: O(log m × log n), Space: O(m×n).

Common Approaches

✓ 2D Binary Indexed Tree (Fenwick Tree)

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

Implement a 2D Binary Indexed Tree (Fenwick Tree) that maintains partial sums efficiently. Both update and range sum operations run in O(log m × log n) time, making it optimal for scenarios with frequent updates and queries.

2D Prefix Sum with Rebuild

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

Use a 2D prefix sum array where prefix[i][j] contains sum of rectangle from (0,0) to (i,j). Range queries are O(1) using inclusion-exclusion principle, but we rebuild the entire prefix array after each update.

Brute Force - Direct Calculation

⏱️ Time: O(m×n) Space: O(1)

Simply store the original matrix and for each sumRegion query, iterate through all cells in the specified rectangle to calculate the sum. Updates are O(1) but queries are slow.

2D Binary Indexed Tree (Fenwick Tree) — Algorithm Steps

Build 2D BIT from original matrix
For updates: propagate change through BIT structure
For queries: sum appropriate BIT ranges using inclusion-exclusion

Visualization

Tap to expand

Step-by-Step Walkthrough

BIT Structure

Tree-like partial sum organization

Update Path

Propagate changes upward O(log n)

Query Path

Accumulate sums downward O(log n)

Code -

solution.c — C

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

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

void updateBIT(NumMatrix* obj, int row, int col, int delta) {
    for (int i = row; i <= obj->rows; i += i & (-i)) {
        for (int j = col; j <= obj->cols; j += j & (-j)) {
            obj->bit[i][j] += delta;
        }
    }
}

int queryBIT(NumMatrix* obj, int row, int col) {
    int total = 0;
    for (int i = row; i > 0; i -= i & (-i)) {
        for (int j = col; j > 0; j -= j & (-j)) {
            total += obj->bit[i][j];
        }
    }
    return total;
}

NumMatrix* numMatrixCreate(int** matrix, int matrixSize, int* matrixColSize) {
    NumMatrix* obj = malloc(sizeof(NumMatrix));
    obj->matrix = matrix;
    obj->rows = matrixSize;
    obj->cols = matrixColSize[0];
    
    obj->bit = malloc((matrixSize + 1) * sizeof(int*));
    for (int i = 0; i <= matrixSize; i++) {
        obj->bit[i] = calloc(matrixColSize[0] + 1, sizeof(int));
    }
    
    for (int i = 0; i < matrixSize; i++) {
        for (int j = 0; j < matrixColSize[0]; j++) {
            updateBIT(obj, i + 1, j + 1, matrix[i][j]);
        }
    }
    
    return obj;
}

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

int numMatrixSumRegion(NumMatrix* obj, int row1, int col1, int row2, int col2) {
    return queryBIT(obj, row2 + 1, col2 + 1) -
           queryBIT(obj, row1, col2 + 1) -
           queryBIT(obj, row2 + 1, col1) +
           queryBIT(obj, row1, col1);
}

int main() {
    printf("[]\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log m × log n)

Both update and query traverse log m levels vertically and log n levels horizontally in BIT

⚡ Linearithmic

Space Complexity

O(m×n)

Additional m×n BIT array plus original matrix storage

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~35 min Avg. Time

982 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

2D Binary Indexed Tree (Fenwick Tree) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler