Making A Large Island

Making A Large Island - Problem

You are given an n x n binary matrix grid. You are allowed to change at most one 0 to be 1.

Return the size of the largest island in grid after applying this operation.

An island is a 4-directionally connected group of 1s.

Input & Output

Example 1 — Basic Island Connection

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

› Output: 3

💡 Note: Change either 0 to 1: grid becomes [[1,1],[0,1]] or [[1,0],[1,1]]. Both create an island of size 3.

Example 2 — Multiple Disconnected Islands

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

› Output: 4

💡 Note: Change the 0 at position (1,1) to 1. The entire grid becomes land, creating one island of size 4.

Example 3 — All Water

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

› Output: 1

💡 Note: Change any 0 to 1. Since no islands exist to connect, the maximum size is 1.

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 500
grid[i][j] is either 0 or 1

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 a Amazon 8

The key insight is to avoid recalculating island sizes by pre-labeling each island with a unique ID and storing their sizes. The optimal island labeling approach uses two passes: first to label and measure all existing islands, then to test each water position by summing adjacent island sizes. Time: O(n²), Space: O(n²)

Common Approaches

✓ Brute Force - Try Every Position

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

Try changing every 0 to 1, then use DFS/BFS to find the size of the connected island containing that position. Return the maximum size found across all attempts.

Island Labeling with DFS

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

First pass: use DFS to label each island with a unique ID and calculate their sizes. Second pass: for each water cell, check which labeled islands it can connect and sum their sizes.

Brute Force - Try Every Position — Algorithm Steps

Step 1: For each cell containing 0, temporarily change it to 1
Step 2: Use DFS/BFS to calculate the size of the island containing this cell
Step 3: Restore the cell to 0 and track the maximum island size found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Water Cell

Locate a cell with value 0

Test Bridge

Temporarily change 0 to 1 and measure island

Track Maximum

Keep the largest island size found

Code -

solution.c — C

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

int dfs(int** grid, int n, int i, int j, bool** visited) {
    if (i < 0 || i >= n || j < 0 || j >= n || visited[i][j] || grid[i][j] == 0) {
        return 0;
    }
    visited[i][j] = true;
    return 1 + dfs(grid, n, i+1, j, visited) + dfs(grid, n, i-1, j, visited) + 
           dfs(grid, n, i, j+1, visited) + dfs(grid, n, i, j-1, visited);
}

int solution(int** grid, int n) {
    int maxSize = 0;
    bool hasZero = false;
    
    // Try changing each 0 to 1
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) {
                hasZero = true;
                grid[i][j] = 1;  // Temporarily change
                
                // Create visited array
                bool** visited = (bool**)malloc(n * sizeof(bool*));
                for (int k = 0; k < n; k++) {
                    visited[k] = (bool*)calloc(n, sizeof(bool));
                }
                
                int size = dfs(grid, n, i, j, visited);
                if (size > maxSize) {
                    maxSize = size;
                }
                
                // Free visited array
                for (int k = 0; k < n; k++) {
                    free(visited[k]);
                }
                free(visited);
                
                grid[i][j] = 0;  // Restore
            }
        }
    }
    
    // If no zeros found, return total size
    if (!hasZero) {
        return n * n;
    }
    
    return maxSize;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple parsing for small grids - assumes format [[1,0],[0,1]]
    int n = 0;
    // Count rows by counting '],' patterns + 1
    for (int i = 0; line[i]; i++) {
        if (line[i] == ']' && line[i+1] == ',') n++;
    }
    n++; // Add 1 for the last row
    
    int** grid = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = (int*)malloc(n * sizeof(int));
    }
    
    // Parse the grid (simplified parser)
    int row = 0, col = 0;
    for (int i = 0; line[i]; i++) {
        if (line[i] >= '0' && line[i] <= '9') {
            grid[row][col++] = line[i] - '0';
        } else if (line[i] == ']' && line[i+1] == ',') {
            row++;
            col = 0;
        }
    }
    
    int result = solution(grid, n);
    printf("%d\n", result);
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

For each of n² cells, we might do DFS on entire n² grid

✓ Linear Growth

Space Complexity

O(n²)

DFS recursion stack can go up to n² depth in worst case

⚠ Quadratic Space

89.4K Views

Medium Frequency

~25 min Avg. Time

1.9K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Try Every Position — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler