Number of Submatrices That Sum to Target - Problem

Given a matrix and a target, return the number of non-empty submatrices that sum to target.

A submatrix x1, y1, x2, y2 is the set of all cells matrix[x][y] with x1 <= x <= x2 and y1 <= y <= y2.

Two submatrices (x1, y1, x2, y2) and (x1', y1', x2', y2') are different if they have some coordinate that is different: for example, if x1 != x1'.

Input & Output

Example 1 — Basic 2x2 Matrix

$ Input: matrix = [[0,1],[0,1]], target = 1

› Output: 4

💡 Note: Four submatrices sum to 1: [0,1] (top-right cell), [0,1] (bottom-right cell), [[1],[1]] (right column), and [1] (each individual 1)

Example 2 — Larger Matrix

$ Input: matrix = [[1,-1],[-1,1]], target = 0

› Output: 5

💡 Note: Five submatrices sum to 0: four 2x1 rectangles ([1,-1], [-1,1], [1],[-1]], [[1],[-1]]) and the entire 2x2 matrix

Example 3 — Single Element

$ Input: matrix = [[904]], target = 0

› Output: 0

💡 Note: Only one submatrix exists (the single cell with value 904), but it doesn't sum to 0

Constraints

1 ≤ matrix.length ≤ 100
1 ≤ matrix[i].length ≤ 100
-1000 ≤ matrix[i][j] ≤ 1000
-10⁸ ≤ target ≤ 10⁸

Visualization

Tap to expand

Asked in

G Google 8 a Amazon 5 f Facebook 4

The key insight is converting the 2D submatrix sum problem into multiple 1D subarray sum problems. Build a 2D prefix sum array, then for each pair of rows, create a 1D array of column sums and use hash map technique to count subarrays with target sum. Best approach uses prefix sums with hash map. Time: O(m²n), Space: O(mn)

Common Approaches

✓ Brute Force

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

Enumerate all possible top-left and bottom-right corners of submatrices. For each submatrix, calculate the sum by iterating through all cells and count those that equal the target.

Prefix Sum with Hash Map

⏱️ Time: O(m²n) Space: O(mn)

Build a 2D prefix sum array, then for each pair of rows, create a 1D array of column sums and use hash map to count subarrays with target sum. This reduces the 2D problem to multiple 1D problems.

Brute Force — Algorithm Steps

Iterate through all possible top-left corners (r1, c1)
For each top-left, iterate through all possible bottom-right corners (r2, c2)
Calculate sum of submatrix from (r1,c1) to (r2,c2)
Count submatrices with sum equal to target

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Top-Left

Pick starting corner (r1,c1)

Choose Bottom-Right

Pick ending corner (r2,c2)

Calculate Sum

Sum all cells in rectangle

Count Matches

Increment if sum equals target

Code -

solution.c — C

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

int solution(int** matrix, int matrixSize, int* matrixColSize, int target) {
    if (matrixSize == 0 || matrixColSize[0] == 0) return 0;
    
    int m = matrixSize, n = matrixColSize[0];
    int count = 0;
    
    // Try all possible top-left corners
    for (int r1 = 0; r1 < m; r1++) {
        for (int c1 = 0; c1 < n; c1++) {
            // Try all possible bottom-right corners
            for (int r2 = r1; r2 < m; r2++) {
                for (int c2 = c1; c2 < n; c2++) {
                    // Calculate sum of submatrix
                    int total = 0;
                    for (int r = r1; r <= r2; r++) {
                        for (int c = c1; c <= c2; c++) {
                            total += matrix[r][c];
                        }
                    }
                    
                    if (total == target) count++;
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    
    // Read matrix line
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    // Parse the matrix
    static int matrix[100][100];
    int m = 0, n = 0;
    
    char* p = line;
    // Skip opening brackets
    while (*p && (*p == '[' || *p == ' ' || *p == '\n')) p++;
    
    int row = 0, col = 0;
    int num = 0, negative = 0, hasNum = 0;
    
    while (*p) {
        if (*p == '-') {
            negative = 1;
            p++;
        } else if (*p >= '0' && *p <= '9') {
            num = num * 10 + (*p - '0');
            hasNum = 1;
            p++;
        } else if (*p == ',' || *p == ']') {
            if (hasNum) {
                matrix[row][col] = negative ? -num : num;
                col++;
                num = 0;
                negative = 0;
                hasNum = 0;
            }
            if (*p == ']' && col > 0) {
                if (col > n) n = col;
                row++;
                col = 0;
            }
            p++;
        } else {
            p++;
        }
    }
    
    m = row;
    
    // Read target
    int target;
    scanf("%d", &target);
    
    // Create matrix pointers
    int** matrixPtrs = (int**)malloc(m * sizeof(int*));
    int* matrixColSize = (int*)malloc(m * sizeof(int));
    
    for (int i = 0; i < m; i++) {
        matrixPtrs[i] = (int*)malloc(n * sizeof(int));
        matrixColSize[i] = n;
        for (int j = 0; j < n; j++) {
            matrixPtrs[i][j] = matrix[i][j];
        }
    }
    
    // Call solution
    int result = solution(matrixPtrs, m, matrixColSize, target);
    printf("%d\n", result);
    
    // Cleanup
    for (int i = 0; i < m; i++) {
        free(matrixPtrs[i]);
    }
    free(matrixPtrs);
    free(matrixColSize);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

Four nested loops: O(m) × O(m) × O(n) × O(n) for all submatrix combinations

⚠ Quadratic Growth

Space Complexity

O(1)

Only uses constant extra variables

✓ Linear Space

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

Number of Submatrices That Sum to Target - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler