Largest Plus Sign - Practice Coding Problems

Largest Plus Sign - Problem

The Plus Sign Mining Challenge

Imagine you're a mining engineer surveying a n × n grid of land for the perfect spot to build a plus-shaped mining facility. The entire grid is initially suitable for construction (all 1's), but some locations have been marked as unusable due to mines (0's).

Your goal is to find the largest possible plus sign that can be built on this grid. A plus sign of order k has:
• A center point with value 1
• Four arms extending in cardinal directions (up, down, left, right)
• Each arm has exactly k-1 consecutive 1's

For example, a plus sign of order 3 looks like:

Return the order of the largest plus sign you can construct, or 0 if no plus sign is possible.

Input & Output

example_1.py — Basic Case

$ Input: n = 5, mines = [[4, 2]]

› Output: 2

💡 Note: In a 5×5 grid with one mine at position [4,2], the largest plus sign has order 2. It can be centered at positions like [2,2] with arms extending 1 cell in each direction.

example_2.py — No Mines

$ Input: n = 1, mines = []

› Output: 1

💡 Note: A 1×1 grid with no mines can form a plus sign of order 1 (just the center cell itself).

example_3.py — All Mines

$ Input: n = 2, mines = [[0,0],[0,1],[1,0],[1,1]]

› Output: 0

💡 Note: When all cells are mines, no plus sign can be formed, so the answer is 0.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n² cells, we potentially check O(n) cells in each direction

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 500
1 ≤ mines.length ≤ 5000
0 ≤ x_i, y_i < n
All the pairs (x_i, y_i) are unique

Asked in

The optimal approach uses dynamic programming to pre-compute the maximum consecutive 1's from each cell in all four directions. This avoids the redundant calculations of the brute force approach, achieving O(n²) time complexity instead of O(n³). The key insight is that a plus sign's order is determined by its shortest arm, so we can efficiently find the optimal center by taking the minimum of the four directional arm lengths at each position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Center)	O(n³)	O(1)	Try every cell as a potential plus center and expand in all directions
Dynamic Programming (Optimal)	O(n²)	O(n²)	Pre-compute arm lengths in all directions using DP for O(n²) solution

Brute Force (Check Every Center) — Algorithm Steps

Iterate through each cell (i, j) as a potential center
For each center, expand in 4 directions until hitting a 0 or boundary
Calculate the minimum arm length across all 4 directions
Track the maximum plus order found so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Pick Center

Choose a cell as potential plus center

Expand Up

Count consecutive 1's going up until hitting 0 or boundary

Expand Down

Count consecutive 1's going down

Expand Left/Right

Count consecutive 1's in both horizontal directions

Find Minimum

Plus order = minimum of all 4 arm lengths

Code -

solution.c — C

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

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

int max(int a, int b) {
    return a > b ? a : b;
}

int orderOfLargestPlusSign(int n, int** mines, int minesSize, int* minesColSize) {
    // Create the grid
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            grid[i][j] = 1;
        }
    }
    
    // Mark mines
    for (int i = 0; i < minesSize; i++) {
        grid[mines[i][0]][mines[i][1]] = 0;
    }
    
    int maxOrder = 0;
    
    // Try each cell as center
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) continue;
            
            // Find arm length in each direction
            int armLength = n;
            
            // Check up
            for (int k = 0; k <= i && k < armLength; k++) {
                if (grid[i - k][j] == 0) {
                    armLength = min(armLength, k);
                    break;
                }
            }
            
            // Check down
            for (int k = 0; k < n - i && k < armLength; k++) {
                if (grid[i + k][j] == 0) {
                    armLength = min(armLength, k);
                    break;
                }
            }
            
            // Check left
            for (int k = 0; k <= j && k < armLength; k++) {
                if (grid[i][j - k] == 0) {
                    armLength = min(armLength, k);
                    break;
                }
            }
            
            // Check right
            for (int k = 0; k < n - j && k < armLength; k++) {
                if (grid[i][j + k] == 0) {
                    armLength = min(armLength, k);
                    break;
                }
            }
            
            maxOrder = max(maxOrder, armLength);
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return maxOrder;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

For each of n² cells, we potentially check O(n) cells in each direction

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

1 ≤ n ≤ 500
1 ≤ mines.length ≤ 5000
0 ≤ x_i, y_i < n
All the pairs (x_i, y_i) are unique

25.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check Every Center) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler