Count Square Submatrices with All Ones - Practice Coding Problems

Count Square Submatrices with All Ones - Problem

You're given an m × n binary matrix containing only 0s and 1s. Your task is to count how many square submatrices contain all ones.

A square submatrix is a contiguous block of cells arranged in a square shape (same width and height). For example, in a 3×3 matrix, you could have 1×1, 2×2, or 3×3 square submatrices.

Goal: Return the total count of all square submatrices that contain only 1s.

Example: In matrix [[1,1],[1,1]], there are 5 valid squares: four 1×1 squares and one 2×2 square.

Input & Output

example_1.py — Basic 2×2 Matrix

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

› Output: 5

💡 Note: There are 4 squares of size 1×1 and 1 square of size 2×2. Total = 4 + 1 = 5 squares.

example_2.py — Matrix with Zeros

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

› Output: 7

💡 Note: There are 6 squares of size 1×1 (only the 1s) and 1 square of size 2×2 (bottom-right). Total = 6 + 1 = 7 squares.

example_3.py — All Zeros

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

› Output: 0

💡 Note: No squares can be formed with all ones since the matrix contains only zeros.

Visualization

Tap to expand

Understanding the Visualization

Start with base cases

First row and column can only have 1×1 squares

Look at neighbors

For any cell, check top, left, and diagonal neighbors

Find the bottleneck

The minimum of the three neighbors limits your square size

Add one more

If current cell is 1, you can extend the smallest neighbor square by 1

Key Takeaway

🎯 Key Insight: The number of squares ending at position (i,j) equals the side length of the largest square ending there!

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n positions, we check up to min(m,n) square sizes, and each check takes O(min(m,n)²) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts

✓ Linear Space

Constraints

1 ≤ matrix.length, matrix[i].length ≤ 300
matrix[i][j] is 0 or 1
The matrix is rectangular (all rows have same length)

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses Dynamic Programming with the key insight that dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1. Each dp[i][j] represents both the side length of the largest square ending at (i,j) and the count of squares ending at that position. Time: O(mn), Space: O(mn).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Squares)	O(m²n²)	O(1)	Check every possible square submatrix by examining all positions and sizes
Dynamic Programming (Optimal)	O(mn)	O(mn)	Use DP to count squares ending at each position efficiently

Brute Force (Check All Squares) — Algorithm Steps

Iterate through each cell (i, j) as potential top-left corner
For each position, try square sizes from 1 to min(m-i, n-j)
For each square size, check if all cells in the square are 1s
If valid, increment the count
Return total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at (0,0)

Try squares of size 1×1, 2×2, 3×3, etc.

Check each cell

For each square size, verify all cells are 1s

Count valid squares

Increment counter for each valid square found

Move to next position

Repeat process for all starting positions

Code -

solution.c — C

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

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

int countSquares(int** matrix, int matrixSize, int* matrixColSize) {
    if (matrixSize == 0 || matrixColSize[0] == 0) {
        return 0;
    }
    
    int m = matrixSize;
    int n = matrixColSize[0];
    int count = 0;
    
    // Try every position as top-left corner
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            // Try every possible square size
            int maxSize = min(m - i, n - j);
            for (int size = 1; size <= maxSize; size++) {
                // Check if square of this size is all 1s
                int valid = 1;
                for (int row = i; row < i + size && valid; row++) {
                    for (int col = j; col < j + size; col++) {
                        if (matrix[row][col] == 0) {
                            valid = 0;
                            break;
                        }
                    }
                }
                
                if (valid) {
                    count++;
                } else {
                    break; // No larger squares possible
                }
            }
        }
    }
    
    return count;
}

int main() {
    // Example usage - create a 3x3 matrix of 1s
    int rows = 3, cols = 3;
    int** matrix = (int**)malloc(rows * sizeof(int*));
    int* colSizes = (int*)malloc(rows * sizeof(int));
    
    for (int i = 0; i < rows; i++) {
        matrix[i] = (int*)malloc(cols * sizeof(int));
        colSizes[i] = cols;
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = 1;
        }
    }
    
    printf("%d\n", countSquares(matrix, rows, colSizes));
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(matrix[i]);
    }
    free(matrix);
    free(colSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n positions, we check up to min(m,n) square sizes, and each check takes O(min(m,n)²) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track positions and counts

✓ Linear Space

Constraints

1 ≤ matrix.length, matrix[i].length ≤ 300
matrix[i][j] is 0 or 1
The matrix is rectangular (all rows have same length)

89.2K Views

Medium-High Frequency

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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Squares) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler