Regions Cut By Slashes - Practice Coding Problems

Regions Cut By Slashes - Problem

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

Imagine you have an n × n grid where each cell contains either a forward slash /, a backslash \, or is empty (space ' '). These slashes act like dividers that split each 1×1 square into separate regions.

Your task is to count the total number of distinct regions created by these slashes across the entire grid. Think of it like counting separate rooms in a floor plan where walls are drawn with slashes!

Input: A string array grid where each string represents a row
Output: An integer representing the number of separate regions

Note: Backslashes are escaped in the input, so \\ represents a single \ character.

Input & Output

example_1.py — Basic 2×2 Grid

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

› Output: 2

💡 Note: The 2×2 grid has a forward slash in top-right and bottom-left cells. This creates two separate regions: one triangular region in the top-left corner and bottom-right corner, and another region connecting the remaining areas.

example_2.py — Cross Pattern

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

› Output: 1

💡 Note: Only one slash divides the top-right cell, but all regions remain connected through the empty spaces, creating just one large connected region.

example_3.py — All Slashes

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

› Output: 5

💡 Note: This creates a complex pattern with multiple slashes. The intersecting slashes create 5 separate regions: 4 corner triangular regions plus 1 central diamond-shaped region.

Constraints

n == grid.length == grid[i].length
1 ≤ n ≤ 60
grid[i][j] is either '/', '\\', or ' '
Space complexity should be optimized for larger grids

Visualization

Tap to expand

Understanding the Visualization

Layout the Grid

Start with an n×n office space where each cell can have diagonal dividers

Add Dividers

Place diagonal dividers (/ or \) according to the grid specification

Identify Regions

Each connected area that you can walk through without crossing dividers is one region

Count Rooms

The total number of such connected areas is our answer

Key Takeaway

🎯 Key Insight: Converting diagonal slash divisions into a standard graph connectivity problem allows us to use efficient algorithms like Union-Find to count connected components without expensive grid expansion.

Asked in

G Google 35 a Amazon 28 f Facebook 22 ⊞ Microsoft 18

The optimal solution uses Union-Find to model each cell as 4 triangular regions. By intelligently connecting triangles based on slash types and merging adjacent regions, we can efficiently count connected components in O(n² α(n)) time with O(n²) space, avoiding the memory overhead of grid expansion approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Union-Find (Optimal)	O(n² α(n))	O(n²)	Divide each cell into 4 triangles and use Union-Find to merge connected regions
Grid Expansion with DFS	O(n²)	O(n²)	Expand each cell to 3×3 and use DFS to count connected components

Union-Find (Optimal) — Algorithm Steps

Create Union-Find structure with 4n² nodes (4 triangles per cell)
For each cell, union appropriate triangles based on slash type
Union adjacent triangles between neighboring cells
Count the number of distinct connected components

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide Cells

Split each cell into 4 triangular regions: top, right, bottom, left

Internal Unions

Connect triangles within each cell based on slash type

Border Unions

Connect adjacent triangles between neighboring cells

Count Components

Union-Find automatically tracks connected components

Code -

solution.c — C

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

typedef struct {
    int *parent;
    int *rank;
    int components;
} UnionFind;

UnionFind* createUnionFind(int n) {
    UnionFind* uf = (UnionFind*)malloc(sizeof(UnionFind));
    uf->parent = (int*)malloc(n * sizeof(int));
    uf->rank = (int*)calloc(n, sizeof(int));
    uf->components = n;
    
    for (int i = 0; i < n; i++) {
        uf->parent[i] = i;
    }
    
    return uf;
}

int find(UnionFind* uf, int x) {
    if (uf->parent[x] != x) {
        uf->parent[x] = find(uf, uf->parent[x]);
    }
    return uf->parent[x];
}

void unionSets(UnionFind* uf, int x, int y) {
    int px = find(uf, x);
    int py = find(uf, y);
    if (px == py) return;
    
    if (uf->rank[px] < uf->rank[py]) {
        uf->parent[px] = py;
    } else if (uf->rank[px] > uf->rank[py]) {
        uf->parent[py] = px;
    } else {
        uf->parent[py] = px;
        uf->rank[px]++;
    }
    uf->components--;
}

int regionsBySlashes(char** grid, int gridSize) {
    int n = gridSize;
    UnionFind* uf = createUnionFind(4 * n * n);
    
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int base = 4 * (i * n + j);
            
            if (grid[i][j] == ' ') {
                unionSets(uf, base, base + 1);
                unionSets(uf, base + 1, base + 2);
                unionSets(uf, base + 2, base + 3);
            } else if (grid[i][j] == '/') {
                unionSets(uf, base, base + 3);
                unionSets(uf, base + 1, base + 2);
            } else if (grid[i][j] == '\\') {
                unionSets(uf, base, base + 1);
                unionSets(uf, base + 2, base + 3);
            }
            
            if (i > 0) {
                unionSets(uf, base, 4 * ((i-1) * n + j) + 2);
            }
            if (j > 0) {
                unionSets(uf, base + 3, 4 * (i * n + (j-1)) + 1);
            }
        }
    }
    
    int result = uf->components;
    free(uf->parent);
    free(uf->rank);
    free(uf);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n² α(n))

We process each cell once, with Union-Find operations having nearly constant amortized time

⚠ Quadratic Growth

Space Complexity

O(n²)

Union-Find structure stores parent and rank arrays for 4n² triangular regions

⚠ Quadratic Space

82.4K Views

Medium Frequency

~25 min Avg. Time

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

Union-Find (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler