Surrounded Regions - Practice Coding Problems

Surrounded Regions - Problem

Imagine you're playing a strategic board game where you need to capture enemy territories! You have an m × n board filled with 'X' (your pieces) and 'O' (enemy pieces).

Your goal is to capture all surrounded enemy regions by flipping them to your side. An enemy region is considered surrounded if:

It consists of connected 'O' cells (horizontally or vertically adjacent)
The entire region is completely enclosed by 'X' cells
No part of the region touches the board edges

When you capture a surrounded region, replace all 'O's in that region with 'X's in-place. Regions that touch the edges are safe and cannot be captured!

Example: A region of 'O's completely surrounded by 'X's gets flipped, but 'O's connected to the border remain unchanged.

Input & Output

example_1.py — Standard Case

$ 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"]]

💡 Note: The 'O' region in the center is completely surrounded and gets captured. The 'O' in the bottom row touches the border and remains safe.

example_2.py — Single Cell

$ Input: board = [["X"]]

› Output: [["X"]]

💡 Note: Board remains unchanged as there are no 'O' regions to capture.

example_3.py — Border Connected

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

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

💡 Note: All 'O' cells are connected to the border, so none can be captured. The board remains unchanged.

Constraints

m == board.length
n == board[i].length
1 ≤ m, n ≤ 200
board[i][j] is 'X' or 'O'
Modify the board in-place

Visualization

Tap to expand

Understanding the Visualization

Scout the Coastline

Send scouts from all coastal positions to map enemy fortresses with sea access

Mark Safe Territories

All fortresses connected to the coast are marked as uncapturable

Launch the Assault

Attack and capture all remaining inland fortresses

Restore Coastal Markers

Remove temporary markings from coastal territories

Key Takeaway

🎯 Key Insight: Instead of checking if regions are surrounded, find which regions are NOT surrounded by starting from the borders!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal approach uses reverse thinking: instead of finding surrounded regions, we find all border-connected regions and mark them as safe using DFS/BFS. Then we capture everything else. This achieves O(mn) time complexity with elegant logic.

Common Approaches

Approach	Time	Space	Notes
✓ Reverse DFS from Borders (Optimal)	O(mn)	O(mn)	Mark all border-connected 'O' regions as safe, then flip everything else
Brute Force (Check Each Region)	O(m²n²)	O(mn)	For each 'O' cell, perform DFS to check if the entire region touches any border

Reverse DFS from Borders (Optimal) — Algorithm Steps

Start DFS from all 'O' cells on the border
Mark all border-connected 'O' cells as 'safe' (temporarily change to another character)
Traverse the entire board: convert remaining 'O's to 'X's
Restore all 'safe' cells back to 'O'

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from borders

Begin DFS from all 'O' cells on board edges

Mark safe regions

Mark all connected 'O' cells as safe

Capture remaining

Convert unmarked 'O's to 'X's

Restore safe cells

Convert marked cells back to 'O'

Code -

solution.c — C

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

void dfs(char** board, int i, int j, int m, int n) {
    if (i < 0 || i >= m || j < 0 || j >= n || board[i][j] != 'O') {
        return;
    }
    
    board[i][j] = 'S'; // Mark as safe
    
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    for (int d = 0; d < 4; d++) {
        dfs(board, i + directions[d][0], j + directions[d][1], m, n);
    }
}

void solve(char** board, int boardSize, int* boardColSize) {
    if (boardSize == 0) return;
    
    int m = boardSize, n = boardColSize[0];
    
    // Mark border-connected regions as safe
    for (int j = 0; j < n; j++) {
        if (board[0][j] == 'O') dfs(board, 0, j, m, n);
        if (board[m-1][j] == 'O') dfs(board, m-1, j, m, n);
    }
    
    for (int i = 0; i < m; i++) {
        if (board[i][0] == 'O') dfs(board, i, 0, m, n);
        if (board[i][n-1] == 'O') dfs(board, i, n-1, m, n);
    }
    
    // Process the board
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'O') {
                board[i][j] = 'X';
            } else if (board[i][j] == 'S') {
                board[i][j] = 'O';
            }
        }
    }
}

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

Time & Space Complexity

Time Complexity

⏱️

O(mn)

Each cell is visited at most once during the border DFS

✓ Linear Growth

Space Complexity

O(mn)

Recursion stack can go up to all cells in worst case (entire board is one region)

⚡ Linearithmic Space

98.5K Views

High Frequency

~15 min Avg. Time

2.3K 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

Reverse DFS from Borders (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler