Number Of Corner Rectangles - Practice Coding Problems

Number Of Corner Rectangles - Problem

Corner Rectangle Counter Challenge

Imagine you're analyzing a digital grid pattern where certain cells are "active" (marked as 1) and others are "inactive" (marked as 0). Your task is to find all possible corner rectangles that can be formed using only the active cells.

A corner rectangle is formed by four distinct active cells (1's) that create the corners of an axis-aligned rectangle. The key insight is that only the corners need to be active - the cells inside or on the edges can be anything!

Goal: Count the total number of such corner rectangles in the given binary matrix.

Example: In a grid like:

[[1,0,1],
 [0,0,0],
 [1,0,1]]

The four corner 1's form exactly 1 corner rectangle.

Input & Output

example_1.py — Basic Rectangle

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

› Output: 1

💡 Note: There is exactly one corner rectangle formed by the four 1's at positions (0,0), (0,2), (2,0), and (2,2). The middle row and column can contain any values since only corners matter.

example_2.py — Multiple Rectangles

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

› Output: 9

💡 Note: With all 1's, we can form multiple rectangles. For each pair of rows (3 pairs total), we have 3 common positions, giving us C(3,2) = 3 rectangles per pair. Total: 3 × 3 = 9 rectangles.

example_3.py — No Rectangles

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

› Output: 0

💡 Note: The 1's are positioned diagonally, so no axis-aligned rectangles can be formed. We need at least 2 rows and 2 columns with 1's at the intersections.

Visualization

Tap to expand

Understanding the Visualization

Identify Corner Posts

Find all positions marked with 1 in the grid

Pair Up Rows

Take any two different rows and see where they both have posts

Count Frame Possibilities

With k matching post positions, you can build k×(k-1)/2 rectangular frames

Sum All Combinations

Add up rectangle counts from all possible row pairs

Key Takeaway

🎯 Key Insight: When two rows share k positions with 1's, they can form exactly k×(k-1)/2 corner rectangles together!

Time & Space Complexity

Time Complexity

⏱️

O(m²n)

For each of the m*(m-1)/2 row pairs, we scan n columns once

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track column positions and counts

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is either 0 or 1
The number of 1's in the grid is in the range [0, 6000]

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 15

The optimal approach uses row pair analysis with combination mathematics. For each pair of rows, count columns where both have 1's. If k such columns exist, they form C(k,2) = k×(k-1)/2 rectangles. This reduces time complexity from O(m²n²) to O(m²n).

Common Approaches

Approach	Time	Space	Notes
✓ Row Pair Analysis (Optimized)	O(m²n)	O(1)	First identify all 1's in each row, then count rectangles between each pair of rows
Brute Force (Check All Combinations)	O(m²n²)	O(1)	Check every possible combination of 4 cells to see if they form a corner rectangle

Row Pair Analysis (Optimized) — Algorithm Steps

For each pair of rows (r1, r2), find all columns where both rows have 1's
Count the number of such matching columns (let's call it k)
Add C(k,2) = k*(k-1)/2 to the total count
Repeat for all pairs of rows

Visualization

Tap to expand

Step-by-Step Walkthrough

Select Row Pair

Choose two different rows to analyze

Find Common 1's

Count columns where both rows have value 1

Apply Combination Formula

Calculate C(k,2) = k*(k-1)/2 for k common positions

Sum All Pairs

Repeat for all row pairs and sum the results

Code -

solution.c — C

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

int countCornerRectangles(int** grid, int gridSize, int* gridColSize) {
    if (gridSize == 0 || gridColSize[0] == 0) return 0;
    
    int m = gridSize;
    int n = gridColSize[0];
    int count = 0;
    
    // For each pair of rows
    for (int r1 = 0; r1 < m; r1++) {
        for (int r2 = r1 + 1; r2 < m; r2++) {
            // Count columns where both rows have 1's
            int commonOnes = 0;
            for (int c = 0; c < n; c++) {
                if (grid[r1][c] == 1 && grid[r2][c] == 1) {
                    commonOnes++;
                }
            }
            
            // If k columns have 1's in both rows,
            // we can form C(k,2) = k*(k-1)/2 rectangles
            if (commonOnes >= 2) {
                count += commonOnes * (commonOnes - 1) / 2;
            }
        }
    }
    
    return count;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n)

For each of the m*(m-1)/2 row pairs, we scan n columns once

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track column positions and counts

✓ Linear Space

Constraints

m == grid.length
n == grid[i].length
1 ≤ m, n ≤ 200
grid[i][j] is either 0 or 1
The number of 1's in the grid is in the range [0, 6000]

28.4K Views

Medium Frequency

~18 min Avg. Time

892 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

Row Pair Analysis (Optimized) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler