Number of Ways of Cutting a Pizza - Practice Coding Problems

Number of Ways of Cutting a Pizza - Problem

Array Dynamic Programming Memoization Matrix Prefix Sum Hard

🍕 Imagine you're at a pizza party and need to share a rectangular pizza with your friends! The pizza is represented as a rows × cols grid where each cell contains either:

'A' - an apple topping 🍎
'.' - an empty space

Your challenge is to cut the pizza into k pieces using exactly k-1 cuts, where each piece must contain at least one apple.

Cutting Rules:

Vertical cuts: Split along column boundaries - left piece goes to current person
Horizontal cuts: Split along row boundaries - top piece goes to current person
The final remaining piece goes to the last person

Return the number of ways to cut the pizza such that everyone gets at least one apple. Since the answer can be huge, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Python

$ Input: pizza = ["A..","AAA","..."], k = 3

› Output: 3

💡 Note: There are 3 ways to cut the pizza: 1) Horizontal cut at row 1, then vertical cut at col 1. 2) Vertical cut at col 1, then horizontal cut at row 1. 3) Horizontal cut at row 1, then vertical cut at col 2. Each way results in 3 pieces where each has at least one apple.

example_2.py — Python

$ Input: pizza = ["A..","AA.","..."], k = 3

› Output: 1

💡 Note: There's only 1 way to cut this pizza into 3 pieces with each piece having an apple: first cut vertically at column 1 (giving left piece with 2 apples), then cut the remaining piece horizontally at row 1.

example_3.py — Python

$ Input: pizza = ["A..","A..","..."], k = 1

› Output: 1

💡 Note: No cuts needed since k=1. The entire pizza goes to one person and it contains apples, so there's 1 way.

Constraints

1 ≤ rows, cols ≤ 50
rows == pizza.length
cols == pizza[i].length
1 ≤ k ≤ 10
pizza[i][j] is either 'A' or '.'
Each piece must contain at least one apple

Visualization

Tap to expand

Understanding the Visualization

Precompute Apple Counts

Build a prefix sum array to instantly check if any rectangle contains apples

Try All Cut Positions

For each state (current rectangle, people left), try every possible horizontal and vertical cut

Validate and Recurse

If the cut piece has apples, recursively solve for the remaining rectangle with one less person

Memoize Results

Cache results to avoid recomputing the same subproblems

Key Takeaway

🎯 Key Insight: Use prefix sums for O(1) apple validation and memoization to avoid recomputing identical subproblems, reducing exponential complexity to polynomial time.

Asked in

A Amazon 15 G Google 8 ⊞ Microsoft 5 f Meta 3

The optimal solution uses dynamic programming with memoization combined with prefix sums. We precompute a 2D prefix sum array to check if any rectangle contains apples in O(1) time, then use memoized recursion with state (row, col, people_left) to count all valid cutting sequences. Time complexity: O(rows × cols × k × (rows + cols)).

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming with Prefix Sums	O(rows * cols * k * (rows + cols))	O(rows * cols * k)	Use memoization and prefix sums to optimize the recursive solution
Brute Force Recursion	O((rowscols)^k rows * cols)	O(k)	Try all possible cuts recursively without optimization

Dynamic Programming with Prefix Sums — Algorithm Steps

Build a prefix sum array to count apples in any rectangle in O(1) time
Use memoization with (row, col, people_left) as the state
For each state, try all possible horizontal and vertical cuts
Use prefix sums to instantly validate if a piece has apples
Return the memoized result to avoid recomputation

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Prefix Sums

Create 2D array where prefix[i][j] = apples from (i,j) to bottom-right

Memoized Recursion

Cache results for (row, col, people_left) states

O(1) Validation

Use prefix sums to instantly check if cut piece has apples

Optimal Cuts

Try all valid cuts and sum up the ways

Code -

solution.c — C

const int MOD = 1000000007;
int prefix[51][51];
int memo[51][51][11];
int g_rows, g_cols;

int dp(int r, int c, int people) {
    if (people == 1) {
        return prefix[r][c] > 0 ? 1 : 0;
    }
    
    if (memo[r][c][people] != -1) {
        return memo[r][c][people];
    }
    
    long long result = 0;
    // Try horizontal cuts
    for (int cutR = r + 1; cutR < g_rows; cutR++) {
        int topApples = prefix[r][c] - prefix[cutR][c];
        if (topApples > 0) {
            result = (result + dp(cutR, c, people - 1)) % MOD;
        }
    }
    
    // Try vertical cuts
    for (int cutC = c + 1; cutC < g_cols; cutC++) {
        int leftApples = prefix[r][c] - prefix[r][cutC];
        if (leftApples > 0) {
            result = (result + dp(r, cutC, people - 1)) % MOD;
        }
    }
    
    return memo[r][c][people] = result;
}

int ways(char** pizza, int pizzaSize, int* pizzaColSize, int k) {
    g_rows = pizzaSize;
    g_cols = pizzaColSize[0];
    
    // Initialize prefix and memo arrays
    memset(prefix, 0, sizeof(prefix));
    memset(memo, -1, sizeof(memo));
    
    // Build prefix sum array
    for (int r = g_rows - 1; r >= 0; r--) {
        for (int c = g_cols - 1; c >= 0; c--) {
            prefix[r][c] = prefix[r + 1][c] + prefix[r][c + 1] - prefix[r + 1][c + 1];
            if (pizza[r][c] == 'A') prefix[r][c]++;
        }
    }
    
    return dp(0, 0, k);
}

Time & Space Complexity

Time Complexity

⏱️

O(rows * cols * k * (rows + cols))

O(rows*cols*k) states, each trying O(rows+cols) cuts

✓ Linear Growth

Space Complexity

O(rows * cols * k)

Memoization table size plus prefix sum array

✓ Linear Space

38.4K Views

Medium Frequency

~35 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

Dynamic Programming with Prefix Sums — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler