Approach: Flood from border

DFS from every border land cell to sink reachable land; count the land that remains

Complexity: O(m*n) time, O(m*n) space.

Full Solution — all languages

class Solution:
    def numEnclaves(self, grid):
        R, C = len(grid), len(grid[0])
        def dfs(r, c):
            if r < 0 or r >= R or c < 0 or c >= C or grid[r][c] != 1:
                return
            grid[r][c] = 0
            dfs(r+1, c); dfs(r-1, c); dfs(r, c+1); dfs(r, c-1)
        for r in range(R):
            dfs(r, 0); dfs(r, C-1)
        for c in range(C):
            dfs(0, c); dfs(R-1, c)
        return sum(1 for r in range(R) for c in range(C) if grid[r][c] == 1)

import java.util.*;
class Solution {
    public int numEnclaves(int[][] grid) {
        int R = grid.length, C = grid[0].length;
        for (int r = 0; r < R; r++) {
            dfs(grid, r, 0);
            dfs(grid, r, C-1);
        }
        for (int c = 0; c < C; c++) {
            dfs(grid, 0, c);
            dfs(grid, R-1, c);
        }
        int cnt = 0;
        for (int r = 0; r < R; r++) for (int c = 0; c < C; c++) if (grid[r][c] == 1) cnt++;
        return cnt;
    }
    void dfs(int[][] grid, int r, int c) {
        int R = grid.length, C = grid[0].length;
        if (r < 0 || r >= R || c < 0 || c >= C || grid[r][c] != 1) return;
        grid[r][c] = 0;
        dfs(grid, r+1, c);
        dfs(grid, r-1, c);
        dfs(grid, r, c+1);
        dfs(grid, r, c-1);
    }
}

#include <bits/stdc++.h> using namespace std;
class Solution {
    public: int numEnclaves(vector<vector<int>>& grid) {
        int R = grid.size(), C = grid[0].size();
        function<void(int,int)> dfs = [&](int r, int c) {
            if (r < 0 || r >= R || c < 0 || c >= C || grid[r][c] != 1) return;
            grid[r][c] = 0;
            dfs(r+1, c);
            dfs(r-1, c);
            dfs(r, c+1);
            dfs(r, c-1);
        };
        for (int r = 0; r < R; r++) {
            dfs(r, 0);
            dfs(r, C-1);
        }
        for (int c = 0; c < C; c++) {
            dfs(0, c);
            dfs(R-1, c);
        }
        int cnt = 0;
        for (int r = 0; r < R; r++) for (int c = 0; c < C; c++) if (grid[r][c] == 1) cnt++;
        return cnt;
    }
};

/**
 * @param {number[][]} grid
 * @return {number}
 */ var numEnclaves = function(grid) {
    const R = grid.length, C = grid[0].length;
    const dfs = (r, c) => {
        if (r < 0 || r >= R || c < 0 || c >= C || grid[r][c] !== 1) return;
        grid[r][c] = 0;
        dfs(r+1, c);
        dfs(r-1, c);
        dfs(r, c+1);
        dfs(r, c-1);
    };
    for (let r = 0; r < R; r++) {
        dfs(r, 0);
        dfs(r, C-1);
    }
    for (let c = 0; c < C; c++) {
        dfs(0, c);
        dfs(R-1, c);
    }
    let cnt = 0;
    for (let r = 0; r < R; r++) for (let c = 0; c < C; c++) if (grid[r][c] === 1) cnt++;
    return cnt;
};

Number of Enclaves

Example 1

Example 2

Constraints