Number of Enclaves - Practice Coding Problems

Number of Enclaves - Problem

You're exploring a mysterious archipelago represented by a binary matrix where 0 represents water and 1 represents land. Your goal is to find landlocked islands - pieces of land that are completely surrounded by water or other land, with no path to escape to the ocean.

Think of it this way: if you were standing on a land cell, you can move in 4 directions (up, down, left, right) to adjacent land cells. If there's any possible path that leads you to the boundary of the grid (the edge where you can "walk off" into the ocean), then that land is not an enclave.

Return the total number of land cells that form enclaves - land from which you cannot reach the boundary no matter how many moves you make.

Example: In a 4×4 grid, if there's a small island in the center completely surrounded by water or boundary-connected land, those center cells would be enclaves.

Input & Output

example_1.py — Basic Island

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

› Output: 3

💡 Note: There are three enclaves: the isolated '1' cells that cannot reach any boundary. The cells at positions (1,0) and (1,2) can potentially reach boundaries, but (2,1) and (2,2) form an enclave that cannot.

example_2.py — All Connected

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

› Output: 0

💡 Note: All land cells are connected to the boundary through the top-right corner land cell, so there are no enclaves. Every '1' can trace a path to the edge.

example_3.py — Complete Enclave

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

› Output: 8

💡 Note: The entire inner island is surrounded by water and cannot reach any boundary. All 8 land cells form one large enclave completely isolated from the edges.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Identify Coast

Find all land cells on the grid boundary - these are your starting points

Coastal Exploration

From each coastal land, explore all connected land using DFS

Mark Reachable

Mark or remove all land that can be reached from the coast

Count Isolated

Count remaining unmarked land cells - these are true enclaves

Key Takeaway

🎯 Key Insight: Instead of asking 'Can this cell reach the boundary?', ask 'Which cells CAN'T be reached FROM the boundary?' This reverse approach is much more efficient!

Asked in

G Google 23 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal approach uses reverse thinking: instead of checking if each cell can reach the boundary, start from the boundary and mark all reachable land. The key insight is to perform DFS from all boundary land cells first, then count the remaining unmarked land cells. This achieves O(m×n) time complexity by visiting each cell at most twice, making it significantly more efficient than checking each cell individually.

Common Approaches

Approach	Time	Space	Notes
✓ Boundary DFS + Counting (Optimal)	O(m×n)	O(m×n)	Mark all boundary-connected land in first pass, count unmarked land in second pass
Brute Force (DFS from Each Cell)	O(m²×n²)	O(m×n)	For each land cell, perform DFS to check if it can reach the boundary

Boundary DFS + Counting (Optimal) — Algorithm Steps

Start DFS/BFS from all boundary land cells simultaneously
Mark all land cells reachable from boundary as 'visited' or change to 0
Make a second pass through the grid
Count all land cells that weren't marked (these are enclaves)
Return the count

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from Boundary

Begin DFS from all land cells on the grid boundary

Mark Connected Land

Mark all land reachable from boundary

Count Remaining

Unmarked land cells are enclaves

Code -

solution.c — C

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

void dfs(int** grid, int i, int j, int m, int n) {
    if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] == 0) {
        return;
    }
    
    grid[i][j] = 0; // Mark as visited
    
    int directions[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
    for (int d = 0; d < 4; d++) {
        dfs(grid, i + directions[d][0], j + directions[d][1], m, n);
    }
}

int numEnclaves(int** grid, int gridSize, int* gridColSize) {
    int m = gridSize, n = gridColSize[0];
    
    // First pass: Mark boundary-connected land
    for (int j = 0; j < n; j++) {
        if (grid[0][j] == 1) dfs(grid, 0, j, m, n);     // Top
        if (grid[m-1][j] == 1) dfs(grid, m-1, j, m, n); // Bottom
    }
    
    for (int i = 0; i < m; i++) {
        if (grid[i][0] == 1) dfs(grid, i, 0, m, n);     // Left
        if (grid[i][n-1] == 1) dfs(grid, i, n-1, m, n); // Right
    }
    
    // Second pass: Count enclaves
    int enclaves = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == 1) {
                enclaves++;
            }
        }
    }
    
    return enclaves;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

Each cell is visited at most once during DFS and once during counting

✓ Linear Growth

Space Complexity

O(m×n)

DFS recursion stack in worst case, or visited array if avoiding input modification

⚡ Linearithmic Space

42.0K Views

Medium Frequency

~15 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

Boundary DFS + Counting (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler