Count Submatrices With All Ones - Practice Coding Problems

Count Submatrices With All Ones - Problem

Given an m x n binary matrix mat containing only 0s and 1s, your task is to count the total number of submatrices that contain all ones.

A submatrix is any rectangular region within the original matrix. This includes single cells, entire rows, entire columns, and any rectangular combination in between.

Example: In a 2x2 matrix with all ones, there are 9 possible submatrices: 4 individual cells, 2 horizontal rectangles, 2 vertical rectangles, and 1 full matrix - all containing only ones!

🎯 Goal: Return the count of all such submatrices efficiently.

Input & Output

example_1.py — Basic 3x3 Matrix

$ Input: mat = [[1,0,1],[1,1,0],[1,1,0]]

› Output: 13

💡 Note: There are 13 submatrices with all ones: 6 of size 1x1, 4 of size 1x2, 2 of size 2x1, and 1 of size 2x2. The zeros break many potential larger rectangles.

example_2.py — Small Square

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

› Output: 9

💡 Note: A 2x2 matrix of all ones contains: 4 submatrices of size 1x1, 2 of size 1x2, 2 of size 2x1, and 1 of size 2x2. Total = 4+2+2+1 = 9.

example_3.py — Single Row

$ Input: mat = [[1,1,0,0]]

› Output: 4

💡 Note: Only the first two consecutive 1s can form submatrices: two 1x1 submatrices, one 1x2 submatrix, plus the individual 1s again gives us 3 total submatrices containing all ones.

Visualization

Tap to expand

Understanding the Visualization

Build Heights

For each row, calculate height of consecutive 1s ending at each position

Create Histogram

Treat each row as a histogram with calculated heights

Count Rectangles

Use monotonic stack to count all rectangles in each histogram

Sum Results

Add up rectangle counts from all rows

Key Takeaway

🎯 Key Insight: Transform 2D matrix counting into 1D histogram problems - each row becomes a histogram where we count rectangles using monotonic stack technique!

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each cell, we may expand to create O(mn) submatrices in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ rows, cols ≤ 150
mat[i][j] is either 0 or 1
Matrix contains only binary values
Submatrix must be rectangular (not arbitrary shape)

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 24

The optimal solution uses a histogram-based approach with monotonic stack. For each row, we treat consecutive 1s as histogram heights and count all possible rectangles efficiently in O(mn) time.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Brute Force (Early Termination)	O(m²n²)	O(1)	Use cumulative checking to avoid redundant scans of the same submatrix
Brute Force (Check All Submatrices)	O(m³n³)	O(1)	Enumerate all possible submatrices and count those with all ones

Optimized Brute Force (Early Termination) — Algorithm Steps

For each cell as top-left corner, start with 1x1 submatrix
Expand rightward column by column while all cells are 1
For each valid width, expand downward row by row
Stop expansion when encountering a 0 and move to next position

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Begin with top-left corner

Expand Right

Extend width while cells are 1

Expand Down

Add rows, updating max width

Count & Continue

Count valid rectangles and move on

Code -

solution.c — C

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

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

int numSubmat(int** mat, int m, int n) {
    int count = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // For each top-left corner (i, j)
            int width = n;
            for (int row = i; row < m; row++) {
                // Update max possible width for current row
                int currWidth = 0;
                for (int col = j; col < min(j + width, n); col++) {
                    if (mat[row][col] == 1) {
                        currWidth++;
                    } else {
                        break;
                    }
                }
                
                width = min(width, currWidth);
                if (width == 0) break;
                
                // Count all submatrices ending at current row
                count += width;
            }
        }
    }
    
    return count;
}

int main() {
    int rows = 3, cols = 3;
    int** mat = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        mat[i] = (int*)malloc(cols * sizeof(int));
    }
    
    int data[3][3] = {{1,0,1},{1,1,0},{1,1,0}};
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            mat[i][j] = data[i][j];
        }
    }
    
    printf("%d\n", numSubmat(mat, rows, cols));
    
    for (int i = 0; i < rows; i++) {
        free(mat[i]);
    }
    free(mat);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each cell, we may expand to create O(mn) submatrices in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ rows, cols ≤ 150
mat[i][j] is either 0 or 1
Matrix contains only binary values
Submatrix must be rectangular (not arbitrary shape)

38.0K Views

Medium Frequency

~25 min Avg. Time

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

Optimized Brute Force (Early Termination) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler