Matrix Block Sum

Matrix Block Sum - Problem

Given a m x n matrix mat and an integer k, return a matrix answer where each answer[i][j] is the sum of all elements mat[r][c] for:

i - k <= r <= i + k
j - k <= c <= j + k
(r, c) is a valid position in the matrix

In other words, for each cell in the matrix, calculate the sum of all elements within a square block of radius k centered at that cell.

Input & Output

Example 1 — Basic 3×3 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 cell (1,1): sum of 3×3 block = 1+2+3+4+5+6+7+8+9 = 45. For corner (0,0): sum of available 2×2 block = 1+2+4+5 = 12.

Example 2 — 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: With k=2, every cell's block covers the entire 3×3 matrix, so all results are 45 (sum of entire matrix).

Example 3 — Single Cell

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

› Output: [[5]]

💡 Note: Single cell matrix: the only block sum is the cell itself = 5.

Constraints

m == mat.length
n == mat[i].length
1 ≤ m, n ≤ 500
1 ≤ k ≤ 500
-10⁴ ≤ mat[i][j] ≤ 10⁴

Visualization

Tap to expand

Asked in

f Facebook 35 G Google 28 a Amazon 22

The key insight is to use 2D prefix sums to avoid recalculating overlapping block regions. Build a cumulative sum array once, then use inclusion-exclusion principle to get any rectangular sum in O(1). Best approach is 2D Prefix Sum with Time: O(m×n), Space: O(m×n).

Common Approaches

✓ 2D Prefix Sum Optimization

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

Build a 2D prefix sum array where each cell contains the sum of all elements from (0,0) to that cell. Then use inclusion-exclusion principle to get any rectangular sum in constant time.

Brute Force - Direct Sum Calculation

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

For each position (i,j) in the result matrix, iterate through all cells within the k-radius square and sum them up. This involves nested loops to traverse the block boundaries.

2D Prefix Sum Optimization — Algorithm Steps

Step 1: Build 2D prefix sum array where prefixSum[i][j] = sum from (0,0) to (i,j)
Step 2: For each result cell (i,j), calculate block boundaries
Step 3: Use formula: sum = prefixSum[r2][c2] - prefixSum[r1-1][c2] - prefixSum[r2][c1-1] + prefixSum[r1-1][c1-1]
Step 4: Handle boundary cases where indices go negative

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sum

Create cumulative sum array where each cell contains sum from (0,0)

Define Rectangle

Mark the k-radius block boundaries around target cell

Apply Formula

Use inclusion-exclusion: total - left - top + overlap

Code -

solution.c — C

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

int** solution(int** mat, int matSize, int* matColSize, int k, int* returnSize, int** returnColumnSizes) {
    int m = matSize, n = matColSize[0];
    *returnSize = m;
    *returnColumnSizes = (int*)malloc(m * sizeof(int));
    
    // Build 2D prefix sum array
    int** prefixSum = (int**)malloc((m + 1) * sizeof(int*));
    for (int i = 0; i <= m; i++) {
        prefixSum[i] = (int*)calloc(n + 1, sizeof(int));
    }
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            prefixSum[i][j] = mat[i-1][j-1] + prefixSum[i-1][j] + prefixSum[i][j-1] - prefixSum[i-1][j-1];
        }
    }
    
    int** answer = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        answer[i] = (int*)malloc(n * sizeof(int));
        (*returnColumnSizes)[i] = n;
    }
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Calculate block boundaries
            int r1 = (i - k > 0) ? i - k : 0;
            int r2 = (i + k < m - 1) ? i + k : m - 1;
            int c1 = (j - k > 0) ? j - k : 0;
            int c2 = (j + k < n - 1) ? j + k : n - 1;
            
            // Convert to 1-indexed for prefix sum
            r1++; r2++; c1++; c2++;
            
            // Calculate sum using inclusion-exclusion
            answer[i][j] = prefixSum[r2][c2] - prefixSum[r1-1][c2] - prefixSum[r2][c1-1] + prefixSum[r1-1][c1-1];
        }
    }
    
    // Free prefix sum array
    for (int i = 0; i <= m; i++) {
        free(prefixSum[i]);
    }
    free(prefixSum);
    
    return answer;
}

int main() {
    // For simplicity, assuming small test case
    int mat_data[3][3] = {{1,2,3},{4,5,6},{7,8,9}};
    int* mat[3];
    for (int i = 0; i < 3; i++) {
        mat[i] = mat_data[i];
    }
    int matColSize[3] = {3,3,3};
    int k = 1;
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(mat, 3, matColSize, k, &returnSize, &returnColumnSizes);
    
    // Print result
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < returnColumnSizes[i]; j++) {
            printf("%d", result[i][j]);
            if (j < returnColumnSizes[i] - 1) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

O(m×n) to build prefix sum array + O(m×n) to calculate all results = O(m×n)

✓ Linear Growth

Space Complexity

O(m×n)

Extra space needed for the 2D prefix sum array of same size as input

⚡ Linearithmic Space

34.5K Views

Medium Frequency

~25 min Avg. Time

892 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 Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler