Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts

Maximum Area of a Piece of Cake After Horizontal and Vertical Cuts - Problem

Imagine you're a pastry chef with a rectangular cake of dimensions h × w. You need to make precise cuts to create individual pieces, and you want to find the largest possible piece after all cuts are made.

You have two arrays:

horizontalCuts[i] - distance from the top of the cake to the i-th horizontal cut
verticalCuts[j] - distance from the left of the cake to the j-th vertical cut

Goal: Return the maximum area of any single piece after making all the specified cuts. Since the result can be very large, return it modulo 10^9 + 7.

Key insight: The largest piece will be formed by the largest gap between consecutive horizontal cuts multiplied by the largest gap between consecutive vertical cuts!

Input & Output

example_1.py — Basic Case

$ Input: h = 5, w = 4, horizontalCuts = [1,2,4], verticalCuts = [1,3]

› Output: 4

💡 Note: After sorting and adding boundaries: horizontal cuts at [0,1,2,4,5] and vertical cuts at [0,1,3,4]. The maximum horizontal gap is 2 (between positions 2 and 4), and maximum vertical gap is 2 (between positions 1 and 3). Maximum area = 2 × 2 = 4.

example_2.py — Larger Cake

$ Input: h = 5, w = 4, horizontalCuts = [3,1], verticalCuts = [1]

› Output: 6

💡 Note: After sorting: horizontal cuts at [0,1,3,5] and vertical cuts at [0,1,4]. Maximum horizontal gap is 2 (between 3 and 5), maximum vertical gap is 3 (between 1 and 4). Maximum area = 2 × 3 = 6.

example_3.py — Edge Case

$ Input: h = 5, w = 4, horizontalCuts = [3], verticalCuts = [3]

› Output: 9

💡 Note: Horizontal cuts at [0,3,5] give max gap of 3. Vertical cuts at [0,3,4] give max gap of 3. Maximum area = 3 × 3 = 9.

Constraints

2 ≤ h, w ≤ 10⁹
0 ≤ horizontalCuts.length ≤ 10⁵
0 ≤ verticalCuts.length ≤ 10⁵
1 ≤ horizontalCuts[i] < h
1 ≤ verticalCuts[i] < w
All cuts are at distinct positions
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Add Boundary Cuts

Imagine cuts at all four edges of the cake (positions 0, h, 0, w)

Sort All Cuts

Arrange all cuts in order from left to right and top to bottom

Find Largest Gaps

Look for the biggest space between consecutive cuts in each direction

Calculate Max Area

The intersection of the largest horizontal and vertical gaps gives the maximum area

Key Takeaway

🎯 Key Insight: The maximum area is always at the intersection of the largest horizontal gap and largest vertical gap - no need to check every possible piece!

Asked in

G Google 45 a Amazon 38 f Meta 29 ⊞ Microsoft 22

The optimal solution uses a clever insight: the maximum area piece is always the product of the largest horizontal gap and largest vertical gap. Instead of checking all possible pieces, we sort the cuts, find the maximum gaps in O(n log n) time, and multiply them together. This is much more efficient than the O(n²m²) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Solution (Sorting + Max Gaps)	O(n log n + m log m)	O(1)	Sort cuts and find maximum gaps in both directions
Brute Force (Check All Pieces)	O(n² × m²)	O(1)	Generate all possible pieces and find the one with maximum area

Optimal Solution (Sorting + Max Gaps) — Algorithm Steps

Add boundary positions (0, h) to horizontal cuts and (0, w) to vertical cuts
Sort both arrays of cuts
Find the maximum gap between consecutive horizontal cuts
Find the maximum gap between consecutive vertical cuts
Return the product of max horizontal and vertical gaps modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Boundaries & Sort

Add edge cuts and sort all cuts

Find Max H-Gap

Find largest gap between horizontal cuts

Find Max V-Gap

Find largest gap between vertical cuts

Multiply Results

Max area = Max H-Gap × Max V-Gap

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int maxArea(int h, int w, int* horizontalCuts, int horizontalCutsSize, int* verticalCuts, int verticalCutsSize) {
    const long long MOD = 1000000007LL;
    
    // Create new arrays with boundaries
    int* hCuts = (int*)malloc((horizontalCutsSize + 2) * sizeof(int));
    int* vCuts = (int*)malloc((verticalCutsSize + 2) * sizeof(int));
    
    // Add boundaries
    for (int i = 0; i < horizontalCutsSize; i++) {
        hCuts[i] = horizontalCuts[i];
    }
    hCuts[horizontalCutsSize] = 0;
    hCuts[horizontalCutsSize + 1] = h;
    
    for (int i = 0; i < verticalCutsSize; i++) {
        vCuts[i] = verticalCuts[i];
    }
    vCuts[verticalCutsSize] = 0;
    vCuts[verticalCutsSize + 1] = w;
    
    // Sort
    qsort(hCuts, horizontalCutsSize + 2, sizeof(int), compare);
    qsort(vCuts, verticalCutsSize + 2, sizeof(int), compare);
    
    // Find maximum gaps
    long long maxHGap = 0;
    for (int i = 1; i < horizontalCutsSize + 2; i++) {
        long long gap = hCuts[i] - hCuts[i-1];
        if (gap > maxHGap) maxHGap = gap;
    }
    
    long long maxVGap = 0;
    for (int i = 1; i < verticalCutsSize + 2; i++) {
        long long gap = vCuts[i] - vCuts[i-1];
        if (gap > maxVGap) maxVGap = gap;
    }
    
    free(hCuts);
    free(vCuts);
    
    return (maxHGap * maxVGap) % MOD;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n + m log m)

Sorting horizontal cuts (n log n) and vertical cuts (m log m), then linear scan

⚡ Linearithmic

Space Complexity

O(1)

Only storing the maximum gaps found, sorting is in-place

✓ Linear Space

38.4K Views

Medium-High Frequency

~15 min Avg. Time

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

Optimal Solution (Sorting + Max Gaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler