Regions Cut By Slashes

Regions Cut By Slashes - Problem

Array Hash Table Depth-First Search Breadth-First Search Union Find Matrix Medium

An n x n grid is composed of 1 x 1 squares where each 1 x 1 square consists of a '/', '\', or blank space ' '. These characters divide the square into contiguous regions.

Given the grid grid represented as a string array, return the number of regions.

Note that backslash characters are escaped, so a '\' is represented as '\\'.

Input & Output

Example 1 — Basic Slash Division

$ Input: grid = [" /","/ "]

› Output: 2

💡 Note: The 2x2 grid has a '/' in positions (0,1) and (1,0). These slashes divide the grid into 2 separate regions: one triangle-shaped region in the top-left and bottom-right corners, and another in the top-right and bottom-left corners.

Example 2 — Backslash Division

$ Input: grid = [" \\","\\ "]

› Output: 2

💡 Note: The backslashes create a different pattern than forward slashes, but still divide the 2x2 grid into 2 regions. The backslashes connect opposite corners, creating 2 triangle-shaped regions.

Example 3 — No Division

$ Input: grid = [" "," "]

› Output: 1

💡 Note: All cells are empty spaces, so there are no barriers dividing the grid. The entire 2x2 area forms one single connected region.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 30
grid[i][j] is either '/', '\\', or ' '

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 f Facebook 6

The key insight is to scale up each 1×1 cell to a 3×3 grid where slashes become clear barrier patterns. Use DFS on the scaled grid to count connected regions. Best approach is 3x Grid Scaling with DFS. Time: O(n²), Space: O(n²)

Common Approaches

✓ 3x Grid Scaling with DFS

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

Transform each 1x1 cell into a 3x3 grid where slashes become clear barrier patterns. Then use DFS to count connected regions in the scaled grid.

Brute Force DFS

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

Attempt to traverse the original grid directly, treating slashes as barriers. This approach struggles with the complex connectivity rules.

3x Grid Scaling with DFS — Algorithm Steps

Step 1: Scale grid from n×n to 3n×3n
Step 2: Draw slash patterns in each 3×3 cell
Step 3: DFS to count connected empty regions

Visualization

Tap to expand

Step-by-Step Walkthrough

Scale Up

Transform 2x2 grid to 6x6 with slash patterns

Draw Slashes

Mark diagonal barrier patterns in scaled grid

Count Regions

DFS finds 2 connected regions

Code -

solution.c — C

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

static int parent[3600];
static int rank_arr[3600];
static int components;

void init_uf(int n) {
    components = n;
    for (int i = 0; i < n; i++) {
        parent[i] = i;
        rank_arr[i] = 0;
    }
}

int find(int x) {
    if (parent[x] != x) {
        parent[x] = find(parent[x]);
    }
    return parent[x];
}

void union_sets(int x, int y) {
    int px = find(x);
    int py = find(y);
    if (px == py) return;
    
    if (rank_arr[px] < rank_arr[py]) {
        parent[px] = py;
    } else if (rank_arr[px] > rank_arr[py]) {
        parent[py] = px;
    } else {
        parent[py] = px;
        rank_arr[px]++;
    }
    components--;
}

int get_id(int i, int j, int k, int n) {
    return 4 * (i * n + j) + k;
}

int solution(char grid[][51], int n) {
    // Each cell has 4 triangular regions: 0=top, 1=right, 2=bottom, 3=left
    init_uf(4 * n * n);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (grid[i][j] == ' ') {
                // No slash - all 4 triangles are connected
                int base = get_id(i, j, 0, n);
                for (int k = 1; k < 4; k++) {
                    union_sets(base, get_id(i, j, k, n));
                }
            } else if (grid[i][j] == '/') {
                // Forward slash connects top-left and bottom-right
                union_sets(get_id(i, j, 0, n), get_id(i, j, 3, n));  // top-left
                union_sets(get_id(i, j, 1, n), get_id(i, j, 2, n));  // bottom-right
            } else if (grid[i][j] == '\\') {
                // Backslash connects top-right and bottom-left
                union_sets(get_id(i, j, 0, n), get_id(i, j, 1, n));  // top-right
                union_sets(get_id(i, j, 2, n), get_id(i, j, 3, n));  // bottom-left
            }
            
            // Connect to adjacent cells
            if (i > 0) {  // Connect to cell above
                union_sets(get_id(i, j, 0, n), get_id(i-1, j, 2, n));
            }
            if (j > 0) {  // Connect to cell left
                union_sets(get_id(i, j, 3, n), get_id(i, j-1, 1, n));
            }
        }
    }
    
    return components;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char grid[51][51];
    int n = 0;
    
    // Parse JSON array manually
    char *p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    bool inQuote = false;
    int strIdx = 0;
    
    while (*p && *p != ']') {
        if (*p == '"') {
            if (!inQuote) {
                inQuote = true;
                strIdx = 0;
            } else {
                inQuote = false;
                grid[n][strIdx] = '\0';
                n++;
            }
        } else if (inQuote) {
            grid[n][strIdx++] = *p;
        }
        p++;
    }
    
    printf("%d\n", solution(grid, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Visit each cell in 3n×3n scaled grid once during DFS

⚠ Quadratic Growth

Space Complexity

O(n²)

3n×3n scaled grid plus DFS recursion stack

⚠ Quadratic Space

52.0K Views

Medium Frequency

~25 min Avg. Time

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

3x Grid Scaling with DFS — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler