Range Sum Query 2D

Range Sum Query 2D - Immutable - Problem

Given a 2D matrix matrix, handle multiple queries of the following type:

Calculate the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).

Implement the NumMatrix class:

NumMatrix(int[][] matrix) Initializes the object with the integer matrix matrix.
int sumRegion(int row1, int col1, int row2, int col2) Returns the sum of the elements of matrix inside the rectangle defined by its upper left corner (row1, col1) and lower right corner (row2, col2).

You must design an algorithm where sumRegion works in O(1) time complexity.

Input & Output

Example 1 — 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 = [[2,1,4,3],[1,1,2,2],[1,2,2,4]]

› Output: [8,11,12]

💡 Note: Query 1: Sum of rectangle from (2,1) to (4,3) = 2+0+1 + 1+0+1 + 0+3+0 = 8. Query 2: Sum from (1,1) to (2,2) = 6+3 + 2+0 = 11. Query 3: Sum from (1,2) to (2,4) = 3+2+1 + 0+1+5 = 12.

Example 2 — Single Cell Query

$ Input: matrix = [[1,2],[3,4]], queries = [[0,0,0,0],[1,1,1,1]]

› Output: [1,4]

💡 Note: Query single cells: matrix[0][0] = 1 and matrix[1][1] = 4.

Example 3 — Full Matrix Query

$ Input: matrix = [[1,2],[3,4]], queries = [[0,0,1,1]]

› Output: [10]

💡 Note: Sum of entire 2x2 matrix: 1+2+3+4 = 10.

Constraints

m == matrix.length
n == matrix[i].length
1 ≤ m, n ≤ 200
-10⁵ ≤ matrix[i][j] ≤ 10⁵
1 ≤ queries.length ≤ 10⁴
0 ≤ row1 ≤ row2 < m
0 ≤ col1 ≤ col2 < n

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 35 f Facebook 30 M Microsoft 25

The key insight is to pre-compute a 2D prefix sum array where each cell contains the sum from (0,0) to that position. Any rectangle query can then be answered in O(1) time using the inclusion-exclusion principle. Best approach is 2D Prefix Sum. Time: O(1) per query, Space: O(mn).

Common Approaches

✓ 2D Prefix Sum

⏱️ Time: O(1) Space: O(mn)

Build a 2D prefix sum array where each cell contains the sum of all elements from (0,0) to that cell. Any rectangle sum can then be calculated using inclusion-exclusion principle in constant time.

Brute Force - Direct Sum

⏱️ Time: O(mn) Space: O(1)

The naive approach calculates the sum by iterating through every cell in the given rectangle for each query. While simple to understand, this becomes very slow when there are many queries.

2D Prefix Sum — Algorithm Steps

Build 2D prefix sum array where prefix[i][j] = sum from (0,0) to (i,j)
For any rectangle query, use formula: prefix[r2][c2] - prefix[r1-1][c2] - prefix[r2][c1-1] + prefix[r1-1][c1-1]
Handle boundary cases when r1=0 or c1=0

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sum

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

Query Formula

Use inclusion-exclusion principle

Instant Result

Calculate in O(1) time

Code -

solution.c — C

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

static int matrix[1000][1000];
static int queries[10000][4];
static int results[10000];
static int prefix[1001][1001];

void solution(int rows, int cols, int numQueries) {
    // Build prefix sum array
    memset(prefix, 0, sizeof(prefix));
    
    for (int i = 1; i <= rows; i++) {
        for (int j = 1; j <= cols; j++) {
            prefix[i][j] = matrix[i-1][j-1] + prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1];
        }
    }
    
    for (int q = 0; q < numQueries; q++) {
        int row1 = queries[q][0], col1 = queries[q][1];
        int row2 = queries[q][2], col2 = queries[q][3];
        // Convert to 1-indexed for prefix array
        results[q] = prefix[row2+1][col2+1] - prefix[row1][col2+1] - prefix[row2+1][col1] + prefix[row1][col1];
    }
}

int parseMatrix(const char* line, int* rows, int* cols) {
    int pos = 1; // skip first '['
    int rowCount = 0;
    int colCount = 0;
    
    while (line[pos] && line[pos] != ']') {
        if (line[pos] == '[') {
            pos++; // skip '['
            int col = 0;
            char numStr[20];
            int numPos = 0;
            
            while (line[pos] && line[pos] != ']') {
                if (line[pos] == ',' || line[pos] == ']') {
                    if (numPos > 0) {
                        numStr[numPos] = '\0';
                        matrix[rowCount][col] = atoi(numStr);
                        col++;
                        numPos = 0;
                    }
                } else if (line[pos] != ' ') {
                    numStr[numPos++] = line[pos];
                }
                pos++;
            }
            if (numPos > 0) {
                numStr[numPos] = '\0';
                matrix[rowCount][col] = atoi(numStr);
                col++;
            }
            
            if (rowCount == 0) colCount = col;
            rowCount++;
            pos++; // skip ']'
        } else {
            pos++;
        }
    }
    
    *rows = rowCount;
    *cols = colCount;
    return 0;
}

int parseQueries(const char* line, int* numQueries) {
    int pos = 1; // skip first '['
    int queryCount = 0;
    
    while (line[pos] && line[pos] != ']') {
        if (line[pos] == '[') {
            pos++; // skip '['
            int idx = 0;
            char numStr[20];
            int numPos = 0;
            
            while (line[pos] && line[pos] != ']') {
                if (line[pos] == ',' || line[pos] == ']') {
                    if (numPos > 0) {
                        numStr[numPos] = '\0';
                        queries[queryCount][idx] = atoi(numStr);
                        idx++;
                        numPos = 0;
                    }
                } else if (line[pos] != ' ') {
                    numStr[numPos++] = line[pos];
                }
                pos++;
            }
            if (numPos > 0) {
                numStr[numPos] = '\0';
                queries[queryCount][idx] = atoi(numStr);
                idx++;
            }
            
            queryCount++;
            pos++; // skip ']'
        } else {
            pos++;
        }
    }
    
    *numQueries = queryCount;
    return 0;
}

int main() {
    char line1[100000], line2[100000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    // Remove newlines
    line1[strcspn(line1, "\n")] = 0;
    line2[strcspn(line2, "\n")] = 0;
    
    int rows, cols, numQueries;
    parseMatrix(line1, &rows, &cols);
    parseQueries(line2, &numQueries);
    
    solution(rows, cols, numQueries);
    
    printf("[");
    for (int i = 0; i < numQueries; i++) {
        printf("%d", results[i]);
        if (i < numQueries - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each query is answered with simple arithmetic operations using pre-computed sums

✓ Linear Growth

Space Complexity

O(mn)

Need to store the 2D prefix sum array of same size as input matrix

✓ Linear Space

125.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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 Prefix Sum — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler