Check if Grid can be Cut into Sections - Practice Coding Problems

Check if Grid can be Cut into Sections - Problem

Array Sorting Medium

Grid Cutting Challenge: You're working with an n × n grid where rectangles are placed strategically. Your mission is to determine if you can make exactly two cuts (either both horizontal OR both vertical) to divide the grid into three sections, where each section contains at least one rectangle.

🎯 The Goal: Given rectangle coordinates in the format [startX, startY, endX, endY], check if it's possible to create three distinct sections using two parallel cuts.

📐 Coordinate System: The grid uses a bottom-left origin, meaning (0, 0) is at the bottom-left corner. Each rectangle is defined by its bottom-left corner (startX, startY) and top-right corner (endX, endY).

Return true if such cuts are possible, false otherwise.

Input & Output

example_1.py — Basic Case

$ Input: n = 4, rectangles = [[0,0,2,1], [2,2,3,4], [0,3,1,4]]

› Output: true

💡 Note: Two horizontal cuts at y=1 and y=2 create three sections: bottom section has rectangle [0,0,2,1], middle section is empty but we can adjust cuts, and top section has rectangles [2,2,3,4] and [0,3,1,4]. We can make horizontal cuts at y=1.5 and y=2.5 to create valid sections.

example_2.py — Vertical Cuts

$ Input: n = 5, rectangles = [[0,1,1,3], [2,0,4,2], [4,3,5,5]]

› Output: true

💡 Note: Two vertical cuts at x=1.5 and x=3.5 create three sections: left section contains [0,1,1,3], middle section contains [2,0,4,2], and right section contains [4,3,5,5].

example_3.py — No Valid Cuts

$ Input: n = 3, rectangles = [[0,0,3,1], [0,2,3,3]]

› Output: false

💡 Note: Both rectangles span the full width, so no vertical cuts can separate them. For horizontal cuts, we'd need one cut to separate sections, but we need exactly two cuts to create three sections, and there's no way to create a valid middle section.

Constraints

3 ≤ n ≤ 10⁴
3 ≤ rectangles.length ≤ 10⁵
rectangles[i].length == 4
0 ≤ start_x < end_x ≤ n
0 ≤ start_y < end_y ≤ n
All rectangles are distinct and do not overlap

Visualization

Tap to expand

Understanding the Visualization

Analyze Layout

Study the placement of all rectangles on the grid

Identify Boundaries

Mark all significant coordinate boundaries where cuts could be effective

Test Cut Pairs

Systematically test pairs of cut positions to find valid solutions

Validate Sections

Ensure each resulting section contains at least one rectangle

Key Takeaway

🎯 Key Insight: Optimal cuts occur at rectangle boundaries, reducing search space dramatically and enabling efficient solutions.

Asked in

G Google 45 a Amazon 32 f Meta 28 ⊞ Microsoft 25

The optimal approach uses coordinate sorting to identify meaningful cut positions, then tests pairs efficiently. Key insight: valid cuts must occur between rectangle boundaries, not at arbitrary positions. This reduces the search space from O(n²) to O(r²) where r is the number of rectangles.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Cut Positions)	O(n²r)	O(1)	Test every possible pair of cut positions on both horizontal and vertical axes
Coordinate Sorting + Two Pointers	O(r² log r)	O(r)	Sort rectangle coordinates and use two pointers to find valid cut positions

Brute Force (Try All Cut Positions) — Algorithm Steps

Generate all possible horizontal cut pairs (y1, y2) where 0 < y1 < y2 < n
For each horizontal pair, check if it creates 3 sections with rectangles
Generate all possible vertical cut pairs (x1, x2) where 0 < x1 < x2 < n
For each vertical pair, check if it creates 3 sections with rectangles
Return true if any valid cut pair is found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Grid

Set up n×n grid with placed rectangles

Test Horizontal Cuts

Try all pairs (y1,y2) and count rectangles in each section

Test Vertical Cuts

Try all pairs (x1,x2) and count rectangles in each section

Validate Sections

Check if all three sections have at least one rectangle

Code -

solution.c — C

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

bool isValidCut(int rectangles[][4], int numRects, int cut1, int cut2, bool isHorizontal) {
    int sections[3] = {0, 0, 0};
    for (int i = 0; i < numRects; i++) {
        int start = isHorizontal ? rectangles[i][1] : rectangles[i][0];
        int end = isHorizontal ? rectangles[i][3] : rectangles[i][2];
        
        if (end <= cut1) sections[0]++;
        else if (start >= cut2) sections[2]++;
        else sections[1]++;
    }
    return sections[0] > 0 && sections[1] > 0 && sections[2] > 0;
}

bool checkValidCuts(int n, int rectangles[][4], int numRects) {
    // Try horizontal cuts
    for (int y1 = 1; y1 < n-1; y1++) {
        for (int y2 = y1+1; y2 < n; y2++) {
            if (isValidCut(rectangles, numRects, y1, y2, true)) return true;
        }
    }
    
    // Try vertical cuts
    for (int x1 = 1; x1 < n-1; x1++) {
        for (int x2 = x1+1; x2 < n; x2++) {
            if (isValidCut(rectangles, numRects, x1, x2, false)) return true;
        }
    }
    
    return false;
}

int main() {
    int n, numRects;
    scanf("%d %d", &n, &numRects);
    int rectangles[100][4];
    for (int i = 0; i < numRects; i++) {
        scanf("%d %d %d %d", &rectangles[i][0], &rectangles[i][1], &rectangles[i][2], &rectangles[i][3]);
    }
    printf("%s\n", checkValidCuts(n, rectangles, numRects) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²r)

O(n²) possible cut pairs × O(r) to check rectangles in each section

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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 (Try All Cut Positions) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler