The word closed is carrying the whole problem. An island is closed when it never touches the frame of the grid, so the cheapest move is to erase the evidence first: flood every patch of land reachable from a border cell, and whatever land is still standing afterwards is closed by definition. The version I started writing was one DFS per island returning whether it ever stepped on a border cell. It solves the problem, and it is what most people reach for, but it hides a trap I have been caught by before (the note at the bottom), and it asks a single traversal to both explore and judge. Drowning the border first leaves the counting loop with one condition: if a cell is still land, it is a new closed island. The first pass already wiped out everything touching row `0`, row `n - 1`, column `0` and column `m - 1`, so the counting pass can ignore the frame and walk the interior only. ## Worked example Take `grid = [[0,0,1,0,0],[0,1,0,1,0],[0,1,1,1,0]]`, three rows by five columns. The border scan finds land at `(0,0)` and floods the component `(0,0)`, `(0,1)`, `(1,0)`, `(2,0)` — it stops at `(1,1)` and `(2,1)`, which are water. Then it finds `(0,3)` and floods `(0,3)`, `(0,4)`, `(1,4)`, `(2,4)`. Both of those islands reached the edge, and both are gone. Now the interior loop runs over `i = 1` and `j = 1..3`. `(1,1)` is water, `(1,2)` is land, so the counter goes to one and that cell is flooded, and `(1,3)` is water. Answer: `1` — the single cell at `(1,2)`, boxed in by `(0,2)`, `(2,2)`, `(1,1)` and `(1,3)`. ## Complexity - **Time** O(n·m) — a cell is turned to water at most once, so across both passes every cell is touched a constant number of times. - **Space** O(n·m) — the explicit stack, which a single snake-shaped island can fill. ## Code (C++) ```cpp class Solution { public: int closedIsland(vector>& grid) { int n = grid.size(), m = grid[0].size(); // Step 1: drown every island that touches the border. // Whatever land survives cannot reach the outside. for (int i = 0; i < n; ++i) { if (grid[i][0] == 0) flood(grid, i, 0); if (grid[i][m - 1] == 0) flood(grid, i, m - 1); } for (int j = 0; j < m; ++j) { if (grid[0][j] == 0) flood(grid, 0, j); if (grid[n - 1][j] == 0) flood(grid, n - 1, j); } // Step 2: every remaining land component is closed by construction. int closed = 0; for (int i = 1; i + 1 < n; ++i) { for (int j = 1; j + 1 < m; ++j) { if (grid[i][j] == 0) { ++closed; flood(grid, i, j); } } } return closed; } private: void flood(vector>& grid, int si, int sj) { int n = grid.size(), m = grid[0].size(); vector> stack{{si, sj}}; grid[si][sj] = 1; while (!stack.empty()) { auto [i, j] = stack.back(); stack.pop_back(); static const int di[4] = {1, -1, 0, 0}; static const int dj[4] = {0, 0, 1, -1}; for (int k = 0; k < 4; ++k) { int ni = i + di[k], nj = j + dj[k]; if (ni < 0 || ni >= n || nj < 0 || nj >= m) continue; if (grid[ni][nj] != 0) continue; grid[ni][nj] = 1; stack.push_back({ni, nj}); } } } }; ``` ## One note Here is the trap in the flag-returning version. You write a `bool dfs(i, j)` that answers “is this island closed”, you notice you have stepped onto a border cell, and the obvious thing is to `return false` on the spot. Do that and the rest of that island stays unmarked: the outer loop walks into it again, calls `dfs` on a cell that is nowhere near the border, and happily counts the same island a second time. The flag has to be accumulated — flood the whole component, combine the results, return at the end — which is exactly the bookkeeping the two-pass version never writes. Two things I keep from this one. When the predicate is about reaching the outside, invert it: flood inward from the boundary and let survival be the proof, instead of interrogating each component about where it has been. And in any flood fill, mark a cell the moment you push it, never when you pop it — `grid[ni][nj] = 1` sits on the line above `stack.push_back` on purpose, and sliding it down past the pop lets one cell enter the stack from two different neighbours.