Largest 1-Bordered Square - Practice Coding Problems

Largest 1-Bordered Square - Problem

You're given a 2D binary grid filled with 0s and 1s. Your task is to find the largest square subgrid where all border cells contain 1s, and return the number of elements in that square.

Think of it like finding the largest picture frame made of 1s - the interior can contain any values, but the entire border must be made of 1s. If no such square exists, return 0.

Key Points:

Only the border needs to be all 1s
The interior can contain 0s or 1s
Return the total number of cells in the largest valid square
A 1×1 square with a 1 counts as a valid bordered square

Input & Output

example_1.py — Basic Valid Square

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

› Output: 9

💡 Note: The 3×3 grid has all border cells as 1s (top row: 1,1,1; bottom row: 1,1,1; left column: 1,1,1; right column: 1,1,1). The center cell is 0, but that's allowed since only borders matter. Area = 3² = 9.

example_2.py — Multiple Valid Squares

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

› Output: 16

💡 Note: Multiple squares are possible: 2×2 at (0,0), 2×2 at (1,1), 3×3 at (1,1), and 4×4 doesn't work due to incomplete borders. The largest valid square is 4×4 starting at (0,1) with all borders being 1s. Area = 4² = 16.

example_3.py — No Valid Square

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

› Output: 1

💡 Note: No square larger than 1×1 can be formed because any 2×2 or larger square will have 0s in its border. However, individual 1s count as 1×1 squares with valid borders. Area = 1² = 1.

Visualization

Tap to expand

Understanding the Visualization

Survey the Workshop

Examine the grid to identify painted (1) and unpainted (0) blocks

Measure Consecutive Blocks

For each position, count how many painted blocks extend right and down

Test Frame Sizes

For each corner position, test if frames of various sizes can be built

Find Largest Frame

Return the area of the largest valid square frame found

Key Takeaway

🎯 Key Insight: Pre-computing consecutive painted blocks allows us to validate frame borders instantly, making the algorithm much faster than checking each border cell individually.

Time & Space Complexity

Time Complexity

⏱️

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

O(m×n) to build DP arrays, then O(m×n) positions × O(min(m,n)) square sizes to check

✓ Linear Growth

Space Complexity

O(m×n)

Two auxiliary arrays to store consecutive 1s in right and down directions

⚡ Linearithmic Space

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is 0 or 1
Only border cells need to be 1s - interior can have any values

Asked in

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

The dynamic programming approach is optimal for this problem. Pre-compute consecutive 1s extending right and down from each cell, then use these arrays to validate square borders in O(1) time instead of checking each border cell individually.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(m×n×min(m,n))	O(m×n)	Pre-compute consecutive 1s in each direction, then efficiently validate squares
Brute Force (Check All Squares)	O(m²×n²)	O(1)	Try every possible square position and size, checking each border cell

Dynamic Programming (Optimal) — Algorithm Steps

Create two DP arrays: right[i][j] = consecutive 1s going right from (i,j), down[i][j] = consecutive 1s going down
Fill the DP arrays by scanning from bottom-right to top-left
For each potential top-left corner, try all possible square sizes
Use DP arrays to validate borders in O(1): check if enough consecutive 1s exist for each border
Return the area of the largest valid square found

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Right Array

Count consecutive 1s extending right from each cell

Build Down Array

Count consecutive 1s extending down from each cell

Fast Border Check

Use DP arrays to validate square borders in O(1) time

Find Maximum

Track the largest valid square found

Code -

solution.c — C

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

int largest1BorderedSquare(int** grid, int m, int n) {
    if (!grid || m == 0 || n == 0) return 0;
    
    // Allocate DP arrays
    int** right = (int**)malloc(m * sizeof(int*));
    int** down = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        right[i] = (int*)calloc(n, sizeof(int));
        down[i] = (int*)calloc(n, sizeof(int));
    }
    
    // Build DP arrays from bottom-right to top-left
    for (int i = m - 1; i >= 0; i--) {
        for (int j = n - 1; j >= 0; j--) {
            if (grid[i][j] == 1) {
                right[i][j] = 1 + (j + 1 < n ? right[i][j + 1] : 0);
                down[i][j] = 1 + (i + 1 < m ? down[i + 1][j] : 0);
            }
        }
    }
    
    int maxSide = 0;
    
    // Try each cell as top-left corner
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int maxPossible = (m - i < n - j) ? m - i : n - j;
            for (int side = 1; side <= maxPossible; side++) {
                if (right[i][j] >= side &&
                    down[i][j] >= side &&
                    right[i + side - 1][j] >= side &&
                    down[i][j + side - 1] >= side) {
                    maxSide = (side > maxSide) ? side : maxSide;
                }
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < m; i++) {
        free(right[i]);
        free(down[i]);
    }
    free(right);
    free(down);
    
    return maxSide * maxSide;
}

int main() {
    printf("Implementation ready\n");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

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

O(m×n) to build DP arrays, then O(m×n) positions × O(min(m,n)) square sizes to check

✓ Linear Growth

Space Complexity

O(m×n)

Two auxiliary arrays to store consecutive 1s in right and down directions

⚡ Linearithmic Space

Constraints

1 ≤ grid.length, grid[i].length ≤ 100
grid[i][j] is 0 or 1
Only border cells need to be 1s - interior can have any values

67.4K Views

Medium-High Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler