Surrounded Regions

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

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

✓ Brute Force (Check Each Region)

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

This approach examines each 'O' cell and performs a complete traversal of its connected region to determine if any cell in that region is on the border. If no border cell is found, the entire region gets captured.

Reverse DFS from Borders (Optimal)

⏱️ Time: O(mn) Space: O(mn)

This is the optimal approach that reverses the problem. Instead of checking which regions are surrounded, we find all regions that are NOT surrounded (connected to borders) and mark them as safe. Then we capture everything else.

Brute Force (Check Each Region) — Algorithm Steps

Iterate through each cell in the board
For each 'O' cell, start a DFS/BFS to explore its connected region
During exploration, check if any cell in the region is on the border
If no border cell found, mark the entire region for capture
Replace all marked cells with 'X'

Visualization

Tap to expand

Step-by-Step Walkthrough

Start from each 'O' cell

Iterate through board and find 'O' cells

Explore entire region

Use DFS to visit all connected 'O' cells

Check border connection

See if any cell in region touches border

Capture if surrounded

Replace all 'O's with 'X's if no border connection

Code -

solution.c — C

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

static char board[1000][1000];
static int m, n;

void dfs(int i, int j) {
    if (i < 0 || i >= m || j < 0 || j >= n || board[i][j] != 'O') {
        return;
    }
    
    // Mark as safe by temporarily changing to a different character
    board[i][j] = 'S';
    
    // Explore all directions
    int directions[4][2] = {{0,1}, {0,-1}, {1,0}, {-1,0}};
    for (int d = 0; d < 4; d++) {
        dfs(i + directions[d][0], j + directions[d][1]);
    }
}

void solve() {
    if (m == 0 || n == 0) {
        return;
    }
    
    // Mark all border-connected 'O' cells as safe
    // Check first and last rows
    for (int j = 0; j < n; j++) {
        if (board[0][j] == 'O') {
            dfs(0, j);
        }
        if (board[m-1][j] == 'O') {
            dfs(m-1, j);
        }
    }
    
    // Check first and last columns  
    for (int i = 0; i < m; i++) {
        if (board[i][0] == 'O') {
            dfs(i, 0);
        }
        if (board[i][n-1] == 'O') {
            dfs(i, n-1);
        }
    }
    
    // Now flip remaining 'O' to 'X' and restore 'S' back to 'O'
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (board[i][j] == 'O') {
                board[i][j] = 'X';  // Surrounded, capture it
            } else if (board[i][j] == 'S') {
                board[i][j] = 'O';  // Safe, restore original
            }
        }
    }
}

int main() {
    char input[100000];
    fgets(input, sizeof(input), stdin);
    
    // Parse the 2D array
    m = 0; n = 0;
    char *p = input;
    
    // Skip to first '['
    while (*p && *p != '[') p++;
    p++; // skip first '['
    
    while (*p && *p != ']') {
        if (*p == '[') {
            p++; // skip '['
            int col = 0;
            while (*p && *p != ']') {
                if (*p == '"') {
                    p++; // skip '"'
                    board[m][col] = *p;
                    col++;
                    p++; // skip the character
                    p++; // skip '"'
                }
                if (*p == ',') {
                    p++; // skip comma
                }
            }
            if (n == 0) n = col;
            m++;
            p++; // skip ']'
        }
        if (*p == ',') {
            p++; // skip comma
        }
    }
    
    solve();
    
    // Output the result in proper 2D format
    printf("[");
    for (int i = 0; i < m; i++) {
        if (i > 0) printf(",");
        printf("[");
        for (int j = 0; j < n; j++) {
            if (j > 0) printf(",");
            printf("\"%c\"", board[i][j]);
        }
        printf("]");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m²n²)

For each of m×n cells, we might explore the entire board in worst case

✓ Linear Growth

Space Complexity

O(mn)

Recursion stack for DFS can go up to all cells in worst case

⚡ 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

Brute Force (Check Each Region) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler