Count Submatrices With All Ones

Count Submatrices With All Ones - Problem

Given an m x n binary matrix mat, return the number of submatrices that have all ones.

A submatrix is a contiguous rectangular region within a matrix. For example, in a 3x3 matrix, there are many possible submatrices of different sizes and positions.

Example: If the matrix is [[1,1,0],[1,1,0],[0,0,1]], we need to count all rectangular regions that contain only 1s.

Input & Output

Example 1 — Basic Matrix

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

› Output: 10

💡 Note: Valid submatrices with all ones: 7 single-cell [1] submatrices at positions (0,0), (0,2), (1,0), (1,1), (2,0), (2,1); 2 vertical 2×1 submatrices at columns 0 and 1; 1 horizontal 1×2 submatrix at row 1; and 1 full 2×2 submatrix in the bottom-left corner

Example 2 — All Ones

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

› Output: 9

💡 Note: Four 1x1 submatrices, four 1x2 or 2x1 submatrices, and one 2x2 submatrix

Example 3 — All Zeros

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

› Output: 0

💡 Note: No submatrix contains all ones

Constraints

1 ≤ m, n ≤ 150
mat[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to convert this into a histogram problem. For each row, calculate the height of consecutive 1s ending at that position, then count rectangles in the resulting histogram using a monotonic stack. Best approach is DP with Histogram. Time: O(mn), Space: O(n)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check All Submatrices

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

For every possible top-left and bottom-right corner pair, check if all cells in that rectangle are 1s. This involves checking all O(m²n²) possible rectangles.

Dynamic Programming with Histogram

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

For each row, calculate consecutive 1s ending at each position (heights). Then for each row, treat it as a histogram base and count all rectangles using stack-based approach.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAXN 150

static int mat[MAXN][MAXN];
static int heights[MAXN];

int solution(int m, int n) {
    if (m == 0 || n == 0) {
        return 0;
    }
    
    memset(heights, 0, sizeof(heights));
    int result = 0;
    
    for (int i = 0; i < m; i++) {
        // Update heights for current row
        for (int j = 0; j < n; j++) {
            if (mat[i][j] == 1) {
                heights[j]++;
            } else {
                heights[j] = 0;
            }
        }
        
        // Count submatrices ending at row i
        for (int j = 0; j < n; j++) {
            if (heights[j] == 0) {
                continue;
            }
            
            int minHeight = heights[j];
            for (int k = j; k < n; k++) {
                if (heights[k] == 0) {
                    break;
                }
                if (heights[k] < minHeight) {
                    minHeight = heights[k];
                }
                result += minHeight;
            }
        }
    }
    
    return result;
}

int parseMatrix(const char* line) {
    int m = 0, n = 0;
    const char* p = line;
    
    if (strcmp(line, "[]") == 0) {
        return 0;
    }
    
    // Skip initial '['
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != '\0' && *p != '\n') {
        // Skip whitespace and commas
        while (*p == ' ' || *p == ',' || *p == '\t') p++;
        
        if (*p == '[') {
            p++; // Skip '['
            n = 0;
            while (*p && *p != ']') {
                while (*p == ' ' || *p == '\t') p++;
                if (*p >= '0' && *p <= '9') {
                    mat[m][n] = *p - '0';
                    n++;
                }
                p++;
            }
            if (*p == ']') p++;
            m++;
        } else if (*p == ']') {
            break;
        } else {
            p++;
        }
    }
    
    return m;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) {
        printf("0\n");
        return 0;
    }
    
    // Remove newline
    line[strcspn(line, "\n")] = 0;
    
    int m = parseMatrix(line);
    int n = 0;
    if (m > 0) {
        // Count columns from first row
        const char* p = line;
        while (*p && *p != '[') p++;
        if (*p == '[') p++;
        while (*p && *p != '[') p++;
        if (*p == '[') {
            p++;
            while (*p && *p != ']') {
                if (*p >= '0' && *p <= '9') {
                    n++;
                }
                p++;
            }
        }
    }
    
    int result = solution(m, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

✓ Linear Space

78.0K Views

Medium Frequency

~25 min Avg. Time

2.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