How do you approach Surrounded Regions?

Any 'O' connected to the border can never be captured - mark those first.

What are common mistakes on Surrounded Regions?

Building the adjacency list in one direction on an undirected graph. Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest. Ignoring self-loops and parallel edges when the constraints allow them.

gitGood.dev

← Back to problems

Surrounded Regions

MediumAlgorithms

Description

Given an m x n board of 'X' and 'O', capture all regions that are 4-directionally surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that region, but only if the region does not touch the border. Return the modified board.

Example 1

Input: board = [["X","X","X","X"],["X","O","O","X"],["X","X","O","X"],["X","O","X","X"]]

Output: [["X","X","X","X"],["X","X","X","X"],["X","X","X","X"],["X","O","X","X"]]

Explanation: Only the border-connected O survives.

Constraints

- m == board.length - n == board[i].length - 1 <= m, n <= 200 - board[i][j] is 'X' or 'O'

Surrounded Regions: approach, complexity and pitfalls

A medium graphs problem, graded against 7 test cases (5 of them hidden).

The pattern: Graphs

Nodes and edges - traversal, connectivity, cycles, and shortest paths.

Reach for it when you see: Explicit edges, a grid treated as a graph, or dependencies between items.

If you are stuck

Show the 2-step hint ladder

Any 'O' connected to the border can never be captured - mark those first.
Flip remaining 'O' to 'X', and restore the marked border-connected ones.

The optimal approach

Show the approach: The approach

Border DFS then flip. From every `'O'` on the border, DFS and temporarily mark the connected region (e.g. as `'T'`). After scanning, any leftover `'O'` is surrounded -> flip to `'X'`; restore every `'T'` back to `'O'`.

Time: O(m·n). Space: O(m·n) recursion.

The full reference solution in every supported language stays in the editor above - reveal it there once you have had a real attempt.

What the tests check

Read off this problem's own test suite, so these are the cases a submission actually has to survive.

Single element. A one-element case is included. Two-pointer and window solutions frequently return the wrong thing when the two indices start out equal.
Duplicate values. Repeated values appear in the input, so any logic that assumes distinct elements - or that skips over equal neighbours - is exercised.

Common Graphs mistakes

These apply to the pattern as a whole, not just this problem.

Building the adjacency list in one direction on an undirected graph.
Assuming the graph is connected. Most inputs allow several components, and one traversal from node 0 misses the rest.
Ignoring self-loops and parallel edges when the constraints allow them.