Range Sum Query 2D - Immutable - Practice Coding Problems

Range Sum Query 2D - Immutable - Problem

Range Sum Query 2D - Immutable

Imagine you're working with a 2D grid of numbers and need to efficiently answer multiple queries about rectangular regions. Given a 2D matrix, you need to handle multiple queries where each query asks for the sum of all elements within a specific rectangle.

🎯 Your Task:
Implement the NumMatrix class with:
• NumMatrix(int[][] matrix) - Initialize with the given matrix
• sumRegion(int row1, int col1, int row2, int col2) - Return sum of rectangle from top-left (row1, col1) to bottom-right (row2, col2)

⚡ Challenge: The sumRegion method must run in O(1) time complexity!

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) should return 8 (sum of the highlighted rectangle)

Input & Output

example_1.py — Basic Rectangle Query

$ 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]] queries = [sumRegion(2,1,4,3), sumRegion(1,1,2,2), sumRegion(1,2,1,4)]

› Output: [8, 11, 6]

💡 Note: First query sums rectangle from (2,1) to (4,3): 2+0+1+1+0+1+0+3+0 = 8. Second query sums (1,1) to (2,2): 6+3+2+0 = 11. Third query sums (1,2) to (1,4): 3+2+1 = 6.

example_2.py — Single Cell Query

$ Input: matrix = [[1,2,3],[4,5,6],[7,8,9]] query = sumRegion(1,1,1,1)

› Output: 5

💡 Note: Query asks for sum of single cell at (1,1), which contains value 5.

example_3.py — Full Matrix Query

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

› Output: 10

💡 Note: Query asks for sum of entire 2x2 matrix: 1+2+3+4 = 10.

Visualization

Tap to expand

Understanding the Visualization

Build Prefix Matrix

Create a matrix where prefix[i][j] = sum of all elements from (0,0) to (i-1,j-1)

Apply Formula

For any rectangle, use: Total Area - Left Excess - Top Excess + Corner Overlap

Get O(1) Result

Rectangle sum = prefix[row2+1][col2+1] - prefix[row1][col2+1] - prefix[row2+1][col1] + prefix[row1][col1]

Key Takeaway

🎯 Key Insight: By preprocessing with 2D prefix sums, we transform expensive rectangle queries into simple O(1) arithmetic using the inclusion-exclusion principle!

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

O(m*n) for preprocessing, O(1) for each query

✓ Linear Growth

Space Complexity

O(m*n)

Additional space for the prefix sum matrix

⚡ Linearithmic Space

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
At most 10⁴ calls will be made to sumRegion

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses 2D Prefix Sum technique to achieve O(1) query time. By preprocessing the matrix to build cumulative sums, we can calculate any rectangle sum using the inclusion-exclusion principle in constant time. This transforms a potentially expensive O(m×n) operation into simple arithmetic.

Common Approaches

Approach	Time	Space	Notes
✓ 2D Prefix Sum (Optimal)	O(m*n)	O(m*n)	Pre-compute 2D prefix sums to answer any rectangle query in O(1) time
Brute Force (Nested Loops)	O(m*n)	O(1)	Calculate sum by iterating through all cells in the rectangle for each query

2D Prefix Sum (Optimal) — Algorithm Steps

Create a prefix sum matrix with dimensions (m+1) × (n+1)
Fill prefix[i][j] = matrix[i-1][j-1] + prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1]
For sumRegion query, use inclusion-exclusion principle
Return prefix[row2+1][col2+1] - prefix[row1][col2+1] - prefix[row2+1][col1] + prefix[row1][col1]

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Matrix

Each cell contains sum from (0,0) to that position

Apply Formula

Use inclusion-exclusion: Total - Left - Top + TopLeft

Get Result

Calculate rectangle sum in constant time

Code -

solution.c — C

typedef struct {
    int** prefix;
    int rows;
    int cols;
} NumMatrix;

NumMatrix* numMatrixCreate(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) return NULL;
    
    NumMatrix* obj = (NumMatrix*)malloc(sizeof(NumMatrix));
    obj->rows = matrixSize + 1;
    obj->cols = matrixColSize[0] + 1;
    
    // Allocate prefix matrix
    obj->prefix = (int**)malloc(obj->rows * sizeof(int*));
    for (int i = 0; i < obj->rows; i++) {
        obj->prefix[i] = (int*)calloc(obj->cols, sizeof(int));
    }
    
    // Build prefix sum matrix
    for (int i = 1; i < obj->rows; i++) {
        for (int j = 1; j < obj->cols; j++) {
            obj->prefix[i][j] = matrix[i-1][j-1] + 
                               obj->prefix[i-1][j] + 
                               obj->prefix[i][j-1] - 
                               obj->prefix[i-1][j-1];
        }
    }
    
    return obj;
}

int numMatrixSumRegion(NumMatrix* obj, int row1, int col1, int row2, int col2) {
    // Inclusion-exclusion principle
    return obj->prefix[row2+1][col2+1] - 
           obj->prefix[row1][col2+1] - 
           obj->prefix[row2+1][col1] + 
           obj->prefix[row1][col1];
}

void numMatrixFree(NumMatrix* obj) {
    for (int i = 0; i < obj->rows; i++) {
        free(obj->prefix[i]);
    }
    free(obj->prefix);
    free(obj);
}

Time & Space Complexity

Time Complexity

⏱️

O(m*n)

O(m*n) for preprocessing, O(1) for each query

✓ Linear Growth

Space Complexity

O(m*n)

Additional space for the prefix sum matrix

⚡ Linearithmic Space

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
At most 10⁴ calls will be made to sumRegion

67.5K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

2D Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler