Number of Submatrices That Sum to Target - Practice Coding Problems

Number of Submatrices That Sum to Target - Problem

Given a 2D matrix and a target sum, count how many submatrices have elements that sum exactly to the target value.

A submatrix is defined by coordinates (x1, y1, x2, y2) representing all cells matrix[x][y] where x1 ≤ x ≤ x2 and y1 ≤ y ≤ y2. Two submatrices are considered different if they have any coordinate that differs.

Example: In matrix [[0,1,0],[1,1,1],[0,1,0]] with target 0, submatrices like [0] (single cell) and [[1,0],[1,0]] (2x2 region) both sum to target values and should be counted.

This is a challenging problem that combines prefix sums with hash table techniques to efficiently count valid rectangular regions in a 2D space.

Input & Output

example_1.py — Basic Matrix

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

› Output: 4

💡 Note: Four submatrices sum to 0: single cells [0] at positions (0,0), (0,2), (2,0), (2,2). Each forms a 1×1 submatrix with sum 0.

example_2.py — Larger Target

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

› Output: 5

💡 Note: Five submatrices sum to 0: four 1×1 submatrices don't work since all values are ±1, but we have: [1,-1], [-1,1] (1×2 rectangles), [1;-1], [-1;1] (2×1 rectangles), and the full 2×2 matrix.

example_3.py — Single Element

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

› Output: 0

💡 Note: The only submatrix is the single cell [904], which sums to 904, not 0. Therefore, no submatrix sums to target.

Visualization

Tap to expand

Understanding the Visualization

Select Row Range

Pick top and bottom boundaries (like selecting row span in Excel)

Compress to 1D

Sum each column between the selected rows to create a single array

Find Target Subarrays

Use hash table technique to find all subarrays in this 1D array that sum to target

Repeat for All Pairs

Try every possible row pair combination and sum up all results

Key Takeaway

🎯 Key Insight: Transform the 2D problem into multiple 1D problems using row compression, then apply the proven hash table technique for subarray sums

Time & Space Complexity

Time Complexity

⏱️

O(m² × n)

O(m²) to try all row pairs, O(n) to process each compressed array with hash table

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n prefix sums, plus O(n) for compressed array

⚡ Linearithmic Space

Constraints

1 ≤ matrix.length ≤ 100
1 ≤ matrix[0].length ≤ 100
-1000 ≤ matrix[i][j] ≤ 1000
-10⁸ ≤ target ≤ 10⁸
All matrix elements and target fit in 32-bit integers

Asked in

G Google 45 f Facebook 32 a Amazon 28 ⊞ Microsoft 23

The optimal solution uses row compression to convert the 2D matrix problem into multiple 1D subarray problems. For each pair of rows, we compress the matrix vertically and apply the classic "Subarray Sum Equals K" technique using prefix sums and a hash table. This achieves O(m²×n) time complexity, which is optimal for this problem.

Common Approaches

Approach	Time	Space	Notes
✓ Prefix Sum + Hash Table (Optimal)	O(m² × n)	O(n)	Convert 2D problem to 1D using row compression and prefix sums with hash table
Brute Force (All Submatrices)	O(m² × n² × m × n)	O(1)	Check every possible submatrix by calculating sum for each combination

Prefix Sum + Hash Table (Optimal) — Algorithm Steps

For each pair of rows (top, bottom), create compressed 1D array
Use prefix sum and hash table to count subarrays with target sum
Hash table stores frequency of each prefix sum seen so far
For each position, check if (current_prefix - target) exists in hash table
Sum up results from all row pair combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix Row Boundaries

Choose top and bottom rows to compress

Create 1D Array

Sum columns between chosen rows

Apply Hash Technique

Use prefix sum + hash table for 1D problem

Count Matches

Find subarrays that sum to target

Code -

solution.c — C

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

#define MAX_VAL 100000

int subarraySum(int* arr, int n, int target) {
    int count = 0;
    int prefixSum = 0;
    int prefixCount[2 * MAX_VAL + 1];
    memset(prefixCount, 0, sizeof(prefixCount));
    prefixCount[MAX_VAL] = 1; // offset for negative values
    
    for (int i = 0; i < n; i++) {
        prefixSum += arr[i];
        // Check if (prefixSum - target) exists
        int needed = prefixSum - target + MAX_VAL;
        if (needed >= 0 && needed <= 2 * MAX_VAL) {
            count += prefixCount[needed];
        }
        // Update frequency of current prefixSum
        int current = prefixSum + MAX_VAL;
        if (current >= 0 && current <= 2 * MAX_VAL) {
            prefixCount[current]++;
        }
    }
    
    return count;
}

int numSubmatrixSumTarget(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 pairs of rows
    for (int top = 0; top < m; top++) {
        int compressed[1000] = {0}; // assuming max columns = 1000
        for (int bottom = top; bottom < m; bottom++) {
            // Add current row to compressed array
            for (int c = 0; c < n; c++) {
                compressed[c] += matrix[bottom][c];
            }
            
            // Now solve 1D subarray sum problem
            count += subarraySum(compressed, n, target);
        }
    }
    
    return count;
}

int main() {
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n)

O(m²) to try all row pairs, O(n) to process each compressed array with hash table

✓ Linear Growth

Space Complexity

O(n)

Hash table stores at most n prefix sums, plus O(n) for compressed array

⚡ Linearithmic Space

Constraints

1 ≤ matrix.length ≤ 100
1 ≤ matrix[0].length ≤ 100
-1000 ≤ matrix[i][j] ≤ 1000
-10⁸ ≤ target ≤ 10⁸
All matrix elements and target fit in 32-bit integers

52.3K Views

Medium-High Frequency

~25 min Avg. Time

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

Prefix Sum + Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler