Making A Large Island - Practice Coding Problems

Making A Large Island - Problem

Making A Large Island

Imagine you're a landscape architect designing the perfect archipelago! You have an n × n grid representing a map where 1s are land and 0s are water. Your goal is to create the largest possible island by converting at most one water cell into land.

An island is a group of land cells (1s) connected horizontally or vertically (4-directional). You need to find the size of the largest island you can create after making your strategic land conversion.

Key Challenge: You can only change one 0 to 1, so choose wisely! If the entire grid is already land, return n².

Input & Output

example_1.py — Basic Island Merge

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

› Output: 3

💡 Note: Changing either 0 to 1 connects the two separate islands (each of size 1) into one large island of size 3.

example_2.py — All Land Grid

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

› Output: 4

💡 Note: The entire grid is already one large island of size 4. No changes needed.

example_3.py — Strategic Placement

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

› Output: 6

💡 Note: Changing the center water cell (1,2) to land connects multiple islands, creating the largest possible combined island.

Visualization

Tap to expand

Understanding the Visualization

Survey Phase

Map and label all existing islands with unique IDs

Catalog Phase

Record the population (size) of each island district

Planning Phase

For each potential bridge location, calculate total connected population

Optimization

Choose the bridge location that creates the largest connected region

Key Takeaway

🎯 Key Insight: Pre-labeling islands with unique IDs and caching their sizes transforms an O(n⁴) problem into an O(n²) solution by eliminating redundant calculations.

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) water cells × O(n²) DFS for each cell

✓ Linear Growth

Space Complexity

O(n²)

DFS recursion stack and visited array

⚠ Quadratic Space

Constraints

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

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 28

The optimal approach uses two-pass island labeling: first assign unique IDs to each island and cache their sizes, then for each water cell, calculate the combined size of adjacent islands. This avoids the O(n⁴) brute force approach by eliminating redundant island size calculations, achieving O(n²) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Water Cell)	O(n⁴)	O(n²)	Try changing each 0 to 1 and recalculate the largest island size
Two-Pass Island Labeling	O(n²)	O(n²)	Pre-label each island with unique ID and size, then calculate combinations efficiently

Brute Force (Try Every Water Cell) — Algorithm Steps

Find all water cells (0s) in the grid
For each water cell, temporarily change it to land (1)
Run DFS/BFS from every land cell to find all island sizes
Track the maximum island size found
Restore the cell back to water and try the next one
Return the maximum island size across all attempts

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Water Cell

Locate each 0 in the grid

Try Conversion

Temporarily change 0 to 1

Calculate Islands

Run DFS from every land cell to find island sizes

Track Maximum

Keep track of the largest island found

Restore & Repeat

Change back to 0 and try next water cell

Code -

solution.c — C

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

int n;
int directions[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};

int dfs(int** grid, bool** visited, int r, int c) {
    if (r < 0 || r >= n || c < 0 || c >= n || visited[r][c] || grid[r][c] == 0) {
        return 0;
    }
    visited[r][c] = true;
    int size = 1;
    for (int i = 0; i < 4; i++) {
        size += dfs(grid, visited, r + directions[i][0], c + directions[i][1]);
    }
    return size;
}

int getMaxIsland(int** grid) {
    bool** visited = (bool**)malloc(n * sizeof(bool*));
    for (int i = 0; i < n; i++) {
        visited[i] = (bool*)calloc(n, sizeof(bool));
    }
    
    int maxSize = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1 && !visited[i][j]) {
                int size = dfs(grid, visited, i, j);
                if (size > maxSize) maxSize = size;
            }
        }
    }
    
    for (int i = 0; i < n; i++) {
        free(visited[i]);
    }
    free(visited);
    
    return maxSize;
}

int largestIsland(int** grid) {
    int maxResult = getMaxIsland(grid);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 0) {
                grid[i][j] = 1;
                int size = getMaxIsland(grid);
                if (size > maxResult) maxResult = size;
                grid[i][j] = 0;
            }
        }
    }
    
    return maxResult;
}

int main() {
    // Input parsing and function call
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

O(n²) water cells × O(n²) DFS for each cell

✓ Linear Growth

Space Complexity

O(n²)

DFS recursion stack and visited array

⚠ Quadratic Space

Constraints

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

42.5K Views

High Frequency

~25 min Avg. Time

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

Brute Force (Try Every Water Cell) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler