Matrix Block Sum - Practice Coding Problems

Matrix Block Sum - Problem

You are given a m x n matrix mat and an integer k. Your task is to create a new matrix answer where each cell answer[i][j] contains the sum of all elements within a square block centered at position (i, j).

Specifically, for each position (i, j), you need to sum all elements mat[r][c] where:

i - k ≤ r ≤ i + k
j - k ≤ c ≤ j + k
(r, c) is a valid position within the matrix boundaries

Think of it as placing a (2k+1) x (2k+1) square window around each cell and summing all values within that window. If the window extends beyond the matrix boundaries, only consider the valid cells within the matrix.

Example: If k = 1, each cell sums a 3x3 block centered on itself.

Input & Output

example_1.py — Basic 3x3 matrix

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]], k = 1

› Output: [[12,21,16],[27,45,33],[24,39,28]]

💡 Note: For each cell, we sum a 3x3 block centered on it. For example, answer[1][1] = sum of entire matrix = 45, while answer[0][0] = 1+2+4+5 = 12 (only 2x2 block fits within bounds).

example_2.py — Larger radius

$ Input: mat = [[1,2,3],[4,5,6],[7,8,9]], k = 2

› Output: [[45,45,45],[45,45,45],[45,45,45]]

💡 Note: Since k=2 creates a 5x5 block, every cell's block covers the entire 3x3 matrix, so all answers are the total sum = 45.

example_3.py — Single cell

$ Input: mat = [[5]], k = 1

› Output: [[5]]

💡 Note: With only one cell, regardless of k value, the block sum is just that single cell's value.

Visualization

Tap to expand

Understanding the Visualization

Understand the Problem

Each cell needs to know the sum of all cells within distance k from it, forming a square block

Brute Force Approach

For each cell, manually sum all cells in its block - simple but slow O(mn×k²)

Prefix Sum Optimization

Pre-compute cumulative sums to enable O(1) rectangular queries

Apply Formula

Use inclusion-exclusion: sum = A - B - C + D where A,B,C,D are prefix sum lookups

Key Takeaway

🎯 Key Insight: Pre-computing prefix sums transforms an O(k²) operation per cell into an O(1) lookup, dramatically improving performance for large matrices or large k values.

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

O(mn) to build prefix matrix + O(mn) to calculate all results = O(mn) total

✓ Linear Growth

Space Complexity

O(m × n)

Additional space needed for the prefix sum matrix

⚡ Linearithmic Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 300
1 ≤ mat[i][j] ≤ 10⁴
0 ≤ k ≤ 100

Asked in

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

The optimal solution uses 2D prefix sums to reduce time complexity from O(mn×k²) to O(mn). Build a prefix sum matrix where each cell contains the sum from top-left corner, then use the inclusion-exclusion principle to calculate any rectangular sum in O(1) time.

Common Approaches

Approach	Time	Space	Notes
✓ 2D Prefix Sum (Optimal)	O(m × n)	O(m × n)	Build prefix sum matrix first, then calculate any block sum in O(1)
Brute Force (Nested Loops)	O(m × n × k²)	O(1)	For each cell, iterate through all cells in its k-radius block

2D Prefix Sum (Optimal) — Algorithm Steps

Create prefix sum matrix: prefix[i][j] = sum of all elements from (0,0) to (i,j)
Build prefix matrix using: prefix[i][j] = mat[i-1][j-1] + prefix[i-1][j] + prefix[i][j-1] - prefix[i-1][j-1]
For each target cell (i,j), calculate block boundaries
Use prefix sum formula to get block sum in O(1): prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]
Store result in answer matrix

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Matrix

Create prefix[i][j] = sum of rectangle from (0,0) to (i-1,j-1)

Define Target Block

For cell (i,j), find block boundaries (r1,c1) to (r2,c2)

Apply Prefix Formula

Block sum = prefix[r2+1][c2+1] - prefix[r1][c2+1] - prefix[r2+1][c1] + prefix[r1][c1]

Store Result

The formula gives us the exact sum in O(1) time

Code -

solution.c — C

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

int max(int a, int b) { return a > b ? a : b; }
int min(int a, int b) { return a < b ? a : b; }

int** matrixBlockSum(int** mat, int m, int n, int k) {
    // Build 2D prefix sum matrix
    int** prefix = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        prefix[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            prefix[i][j] = mat[i-1][j-1] + 
                          prefix[i-1][j] + 
                          prefix[i][j-1] - 
                          prefix[i-1][j-1];
        }
    }
    
    // Calculate result using prefix sums
    int** answer = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        answer[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int r1 = max(0, i - k);
            int r2 = min(m - 1, i + k);
            int c1 = max(0, j - k);
            int c2 = min(n - 1, j + k);
            
            answer[i][j] = prefix[r2+1][c2+1] - 
                          prefix[r1][c2+1] - 
                          prefix[r2+1][c1] + 
                          prefix[r1][c1];
        }
    }
    
    // Free prefix matrix
    for (int i = 0; i <= m; i++) {
        free(prefix[i]);
    }
    free(prefix);
    
    return answer;
}

int main() {
    int m, n, k;
    scanf("%d %d %d", &m, &n, &k);
    
    int** mat = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        mat[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            scanf("%d", &mat[i][j]);
        }
    }
    
    int** result = matrixBlockSum(mat, m, n, k);
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            printf("%d ", result[i][j]);
        }
        printf("\n");
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m × n)

O(mn) to build prefix matrix + O(mn) to calculate all results = O(mn) total

✓ Linear Growth

Space Complexity

O(m × n)

Additional space needed for the prefix sum matrix

⚡ Linearithmic Space

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 300
1 ≤ mat[i][j] ≤ 10⁴
0 ≤ k ≤ 100

42.8K Views

Medium Frequency

~15 min Avg. Time

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