As Far from Land as Possible - Practice Coding Problems

As Far from Land as Possible - Problem

As Far from Land as Possible

Imagine you're a marine biologist studying ocean currents and need to find the most remote water location from any land mass. Given an n × n grid representing a map where 0 represents water and 1 represents land, your task is to find a water cell that is as far as possible from any land cell.

The distance is measured using Manhattan distance: the distance between two cells (x₀, y₀) and (x₁, y₁) is |x₀ - x₁| + |y₀ - y₁|.

Goal: Return the maximum distance from any water cell to the nearest land cell. If the grid contains only land or only water, return -1.

Example: In a 3×3 grid with land at corners, the center water cell would be farthest from all land masses.

Input & Output

example_1.py — Basic Grid

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

› Output: 2

💡 Note: The center water cell (1,1) is farthest from any land, with Manhattan distance 2 to all corner land cells.

example_2.py — Single Land

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

› Output: 4

💡 Note: The bottom-right water cell (2,2) is farthest from the single land cell at (0,0), with distance |2-0| + |2-0| = 4.

example_3.py — Edge Case

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

› Output: -1

💡 Note: Grid contains only land cells, so there's no water to measure distance from.

Visualization

Tap to expand

Understanding the Visualization

Deploy Boats

Launch rescue boats from all islands simultaneously (multi-source BFS)

Expand Search

Boats spread outward in waves, marking distances as they go

Find Remote Location

The last water location reached is farthest from all land

Mission Complete

Return the maximum distance found for optimal supply drop

Key Takeaway

🎯 Key Insight: Multi-source BFS naturally finds the optimal location by expanding from all starting points simultaneously, ensuring we discover the maximum distance efficiently.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each cell is visited exactly once during BFS traversal

⚠ Quadratic Growth

Space Complexity

O(n²)

Distance matrix and BFS queue both use O(n²) space

⚠ Quadratic Space

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 100
grid[i][j] is 0 or 1
Distance is calculated using Manhattan distance formula

Asked in

G Google 42 a Amazon 38 ⊞ Microsoft 25 f Meta 18

The optimal solution uses Multi-source BFS starting from all land cells simultaneously. This creates a natural wave propagation effect that calculates shortest distances to land efficiently in O(n²) time. The key insight is treating all land cells as simultaneous starting points rather than processing each water cell individually.

Common Approaches

Approach	Time	Space	Notes
✓ Multi-source BFS (Optimal)	O(n²)	O(n²)	Start BFS from all land cells simultaneously to find maximum distance

Multi-source BFS (Optimal) — Algorithm Steps

Initialize BFS queue with all land cells (distance 0)
Mark all land cells as visited in the distance matrix
Process each cell in queue, updating distances to unvisited neighbors
Continue until all reachable cells are processed
Return the maximum distance found, or -1 if no water exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Queue

Add all land cells to BFS queue with distance 0

Wave Expansion

Process each cell, expanding to unvisited neighbors

Distance Tracking

Each expansion increases distance by 1

Maximum Found

The last cell reached has maximum distance

Code -

solution.c — C

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

struct Point {
    int row, col, dist;
};

int maxDistance(int** grid, int gridSize, int* gridColSize) {
    int n = gridSize;
    struct Point queue[10000];
    int front = 0, rear = 0;
    
    int** distances = (int**)malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        distances[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            distances[i][j] = -1;
        }
    }
    
    // Add all land cells to queue as starting points
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                queue[rear++] = (struct Point){i, j, 0};
                distances[i][j] = 0;
            }
        }
    }
    
    // If no land or no water, return -1
    if (rear == 0 || rear == n * n) {
        // Free memory
        for (int i = 0; i < n; i++) {
            free(distances[i]);
        }
        free(distances);
        return -1;
    }
    
    int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    int maxDist = 0;
    
    // BFS from all land cells simultaneously
    while (front < rear) {
        struct Point current = queue[front++];
        
        for (int d = 0; d < 4; d++) {
            int newRow = current.row + directions[d][0];
            int newCol = current.col + directions[d][1];
            
            // Check bounds and if cell is unvisited water
            if (newRow >= 0 && newRow < n && newCol >= 0 && newCol < n &&
                distances[newRow][newCol] == -1) {
                
                int newDist = current.dist + 1;
                distances[newRow][newCol] = newDist;
                if (newDist > maxDist) {
                    maxDist = newDist;
                }
                queue[rear++] = (struct Point){newRow, newCol, newDist};
            }
        }
    }
    
    // Free memory
    for (int i = 0; i < n; i++) {
        free(distances[i]);
    }
    free(distances);
    
    return maxDist;
}

int main() {
    int grid_data[3][3] = {{1,0,1},{0,0,0},{1,0,1}};
    int* grid[3] = {grid_data[0], grid_data[1], grid_data[2]};
    int colSizes[3] = {3, 3, 3};
    printf("%d\n", maxDistance(grid, 3, colSizes));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Each cell is visited exactly once during BFS traversal

⚠ Quadratic Growth

Space Complexity

O(n²)

Distance matrix and BFS queue both use O(n²) space

⚠ Quadratic Space

Constraints

n == grid.length
n == grid[i].length
1 ≤ n ≤ 100
grid[i][j] is 0 or 1
Distance is calculated using Manhattan distance formula

76.2K Views

Medium-High Frequency

~18 min Avg. Time

2.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

Multi-source BFS (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler