Number of Enclaves

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

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

✓ Boundary DFS + Counting (Optimal)

⏱️ Time: O(m×n) Space: O(m×n)

This optimal approach reverses the problem: instead of checking if each cell can reach the boundary, we start from the boundary and mark all reachable land cells. The remaining unmarked land cells are enclaves.

Brute Force (DFS from Each Cell)

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

This naive approach examines every land cell individually and performs a depth-first search to determine if there's any path from that cell to the grid boundary. If a path exists, the cell is not an enclave.

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>
#include <string.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 by changing to water
    
    // Explore all 4 directions
    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 m, int n) {
    // First pass: Mark all boundary-connected land
    // Check top and bottom borders
    for (int j = 0; j < n; j++) {
        if (grid[0][j] == 1) {  // Top border
            dfs(grid, 0, j, m, n);
        }
        if (grid[m-1][j] == 1) {  // Bottom border
            dfs(grid, m-1, j, m, n);
        }
    }
    
    // Check left and right borders
    for (int i = 0; i < m; i++) {
        if (grid[i][0] == 1) {  // Left border
            dfs(grid, i, 0, m, n);
        }
        if (grid[i][n-1] == 1) {  // Right border
            dfs(grid, i, n-1, m, n);
        }
    }
    
    // Second pass: Count remaining land cells (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;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    // Count rows
    int rows = 0;
    char* p = input;
    while (*p) {
        if (*p == '[' && *(p+1) != '[' && *(p-1) != '=' && rows > 0) rows++;
        if (*p == '[' && *(p+1) != '[' && rows == 0) rows = 1;
        p++;
    }
    
    if (rows == 0) {
        printf("0\n");
        return 0;
    }
    
    // Parse grid
    int** grid = (int**)malloc(rows * sizeof(int*));
    char* token = input;
    int row = 0;
    
    // Find first row
    while (*token && !(*token == '[' && *(token+1) != '[')) token++;
    
    while (row < rows && *token) {
        if (*token == '[' && *(token+1) != '[') {
            // Found start of a row
            char* end = token + 1;
            while (*end && *end != ']') end++;
            
            char rowStr[1000];
            int len = end - token + 1;
            strncpy(rowStr, token, len);
            rowStr[len] = '\0';
            
            int rowData[1000];
            int cols;
            parseArray(rowStr, rowData, &cols);
            
            grid[row] = (int*)malloc(cols * sizeof(int));
            for (int i = 0; i < cols; i++) {
                grid[row][i] = rowData[i];
            }
            
            row++;
            token = end + 1;
        } else {
            token++;
        }
    }
    
    int cols = 0;
    // Count columns from first row
    char* firstRow = input;
    while (*firstRow && !(*firstRow == '[' && *(firstRow+1) != '[')) firstRow++;
    if (*firstRow) {
        char* end = firstRow + 1;
        while (*end && *end != ']') end++;
        char rowStr[1000];
        int len = end - firstRow + 1;
        strncpy(rowStr, firstRow, len);
        rowStr[len] = '\0';
        int rowData[1000];
        parseArray(rowStr, rowData, &cols);
    }
    
    printf("%d\n", numEnclaves(grid, rows, cols));
    
    // Free memory
    for (int i = 0; i < rows; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m×n)

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

⚠ Quadratic 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