Largest Plus Sign

Largest Plus Sign - Problem

You are given an integer n. You have an n x n binary grid grid with all values initially 1's except for some indices given in the array mines.

The i-th element of the array mines is defined as mines[i] = [x_i, y_i] where grid[x_i][y_i] == 0.

Return the order of the largest axis-aligned plus sign of 1's contained in grid. If there is none, return 0.

An axis-aligned plus sign of 1's of order k has some center grid[r][c] == 1 along with four arms of length k - 1 going up, down, left, and right, and made of 1's. Note that there could be 0's or 1's beyond the arms of the plus sign, only the relevant area of the plus sign is checked for 1's.

Input & Output

Example 1 — Basic Grid

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

› Output: 2

💡 Note: Grid is 5×5 with all 1's except mines at (4,2). The largest plus sign has order 2, can be centered at multiple positions like (1,2), (2,2), etc.

Example 2 — Single Cell

$ Input: n = 1, mines = []

› Output: 1

💡 Note: 1×1 grid with single cell containing 1. The plus sign order is 1 (just the center, no arms).

Example 3 — All Mines

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

› Output: 0

💡 Note: Only cell is a mine (0), so no plus sign can be formed.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 F Facebook 8

The key insight is to pre-compute consecutive 1's from each direction using dynamic programming to avoid redundant calculations. Best approach uses 2D DP with 4 arrays storing arm lengths. Time: O(n²), Space: O(n²)

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force - Check Every Center

⏱️ Time: O(n⁴) Space: O(n²)

Try every cell as potential center, then for each center extend arms up, down, left, right until hitting a 0 or boundary. The order is the minimum arm length plus 1.

Dynamic Programming - Pre-compute Arm Lengths

⏱️ Time: O(n²) Space: O(n²)

Use 4 DP arrays to store how many consecutive 1's exist from each cell going up, down, left, right. Then for each cell, the plus order is the minimum of these 4 values.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

#define MAX_N 1000
#define MAX_DIFF 1001
#define OFFSET 500

int solution(int* nums, int n) {
    if (n <= 2) return n;
    
    // dp[i][diff + OFFSET] = length of longest arithmetic subsequence
    // ending at position i with common difference diff
    int dp[MAX_N][MAX_DIFF];
    memset(dp, 0, sizeof(dp));
    
    int maxLength = 2;
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            int diff = nums[i] - nums[j];
            if (diff < -OFFSET || diff > OFFSET) continue;
            
            int diffIndex = diff + OFFSET;
            // Get length of sequence ending at j with this difference
            int prevLen = dp[j][diffIndex] > 0 ? dp[j][diffIndex] : 1;
            // Extend the sequence to position i
            dp[i][diffIndex] = prevLen + 1;
            if (dp[i][diffIndex] > maxLength) {
                maxLength = dp[i][diffIndex];
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    int nums[MAX_N];
    int n = 0;
    if (strlen(line) > 2) {
        char* token = strtok(line + 1, ",]");
        while (token != NULL) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚠ Quadratic Growth

Space Complexity

⚠ Quadratic Space

28.0K Views

Medium Frequency

~35 min Avg. Time

890 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