Count Square Submatrices with All Ones

Count Square Submatrices with All Ones - Problem

Given a m × n matrix of ones and zeros, return how many square submatrices have all ones.

A square submatrix is a contiguous block of cells that forms a square shape (equal width and height). You need to count all possible squares of any size (1×1, 2×2, 3×3, etc.) where every cell in the square contains the value 1.

Input & Output

Example 1 — Basic 3×3 Matrix

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

› Output: 8

💡 Note: Count squares of all sizes: 8 squares of size 1×1 (at all positions where matrix[i][j]=1). No 2×2 or larger squares are possible due to the 0 at position (1,1) blocking all larger squares. Total = 8.

Example 2 — All Ones

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

› Output: 5

💡 Note: 4 squares of size 1×1 + 1 square of size 2×2 = 5 total squares

Example 3 — Single Row

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

› Output: 2

💡 Note: Only 1×1 squares possible: at positions (0,0) and (0,2) where value is 1

Constraints

1 ≤ matrix.length ≤ 300
1 ≤ matrix[0].length ≤ 300
matrix[i][j] is 0 or 1

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 M Microsoft 32

The key insight is that dp[i][j] represents the side length of the largest square ending at position (i,j), and the total count equals the sum of all dp values. Best approach uses Dynamic Programming with recurrence dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1. Time: O(m×n), Space: O(m×n)

Common Approaches

✓ Brute Force - Check All Squares

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

For each cell as a potential top-left corner, try all possible square sizes and check if every cell in that square contains 1. This requires checking every possible square explicitly.

Dynamic Programming - Build Squares

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

Create a DP table where dp[i][j] represents the side length of the largest square ending at position (i,j). The key insight is that a square at (i,j) depends on the squares at (i-1,j), (i,j-1), and (i-1,j-1).

Brute Force - Check All Squares — Algorithm Steps

For each cell (i,j) as top-left corner
Try all square sizes from 1×1 to maximum possible
Check if all cells in current square are 1
Count valid squares

Visualization

Tap to expand

Step-by-Step Walkthrough

Choose Corner

Pick a cell as top-left corner

Try Sizes

Test squares of increasing size from that corner

Validate

Check if all cells in square contain 1

Code -

solution.c — C

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

int solution(int** matrix, int m, int n) {
    if (m == 0 || n == 0) return 0;
    
    int count = 0;
    
    // Try every possible top-left corner
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Try all possible square sizes from this corner
            int maxSize = (m - i) < (n - j) ? (m - i) : (n - j);
            for (int size = 1; size <= maxSize; size++) {
                // Check if all cells in this square are 1
                int isValid = 1;
                for (int r = i; r < i + size && isValid; r++) {
                    for (int c = j; c < j + size; c++) {
                        if (matrix[r][c] != 1) {
                            isValid = 0;
                            break;
                        }
                    }
                }
                
                if (isValid) {
                    count++;
                } else {
                    break; // No larger squares possible from this corner
                }
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for 2D array
    int matrix[20][20];
    int m = 0, n = 0;
    
    char* ptr = strchr(line, '[');
    if (ptr) ptr++;
    
    while (ptr && *ptr) {
        if (*ptr == '[') {
            ptr++;
            n = 0;
            while (*ptr && *ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9') {
                    matrix[m][n++] = *ptr - '0';
                }
                ptr++;
            }
            m++;
        }
        if (*ptr) ptr++;
    }
    
    // Convert to proper 2D array for function call
    int* rows[20];
    for (int i = 0; i < m; i++) {
        rows[i] = matrix[i];
    }
    
    int result = solution(rows, m, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m² × n² × min(m,n))

For each of m×n positions, try O(min(m,n)) square sizes, checking O(min(m,n)²) cells each

✓ Linear Growth

Space Complexity

O(1)

Only using variables for counters and indices

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~15 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Squares — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler