Minimum Cost for Cutting Cake I - Practice Coding Problems

Minimum Cost for Cutting Cake I - Problem

Minimum Cost for Cutting Cake

Imagine you're a pastry chef tasked with cutting a large m × n rectangular cake into individual 1 × 1 pieces for serving. Each cut you make has a specific cost depending on which line you cut along.

You are given:
• A cake of dimensions m × n
• An array horizontalCut of size m-1, where horizontalCut[i] is the cost to make a horizontal cut along line i
• An array verticalCut of size n-1, where verticalCut[j] is the cost to make a vertical cut along line j

Goal: Find the minimum total cost to cut the entire cake into 1 × 1 pieces.

Key insight: The order of cuts matters! When you make a cut, it affects multiple pieces simultaneously, so making expensive cuts early (when they affect fewer pieces) is better than making them late (when they affect many pieces).

Input & Output

example_1.py — Basic 3×2 Cake

$ Input: m = 3, n = 2, horizontalCut = [1, 3], verticalCut = [5]

› Output: 13

💡 Note: We have a 3×2 cake. Optimal cutting order: 1) Make vertical cut (cost 5×1=5), now we have 2 vertical strips. 2) Make horizontal cut at cost 3 (cost 3×2=6), now we have 4 pieces. 3) Make horizontal cut at cost 1 (cost 1×2=2), final result. Total: 5+6+2=13

example_2.py — Square 2×2 Cake

$ Input: m = 2, n = 2, horizontalCut = [7], verticalCut = [4]

› Output: 11

💡 Note: We have a 2×2 cake. Since horizontal cut costs more (7 > 4), we make it first: 1) Horizontal cut costs 7×1=7. 2) Vertical cut costs 4×2=8 (affects both horizontal strips). Total: 7+8=15. Wait, let's try vertical first: 1) Vertical cut costs 4×1=4. 2) Horizontal cut costs 7×2=14. Total: 4+14=18. So horizontal first gives 7+4=11.

example_3.py — Edge Case 1×3 Cake

$ Input: m = 1, n = 3, horizontalCut = [], verticalCut = [2, 3]

› Output: 5

💡 Note: Only vertical cuts needed. Optimal order is expensive cuts first: 1) Cut with cost 3 first (3×1=3). 2) Cut with cost 2 next (2×1=2). Total: 3+2=5. Note: no horizontal cuts needed since m=1.

Constraints

1 ≤ m, n ≤ 20
horizontalCut.length = m - 1
verticalCut.length = n - 1
1 ≤ horizontalCut[i], verticalCut[j] ≤ 10³
Each cut cost is paid every time that cut line is used

Visualization

Tap to expand

Understanding the Visualization

Identify all cuts

List every horizontal and vertical cut with their costs

Sort by expense

Arrange cuts from most expensive to least expensive

Cut greedily

Always make the most expensive remaining cut first

Track multipliers

Each cut's cost is multiplied by the number of existing pieces it affects

Key Takeaway

🎯 Key Insight: The greedy approach works because cut costs multiply by piece count - make expensive cuts when piece count is low!

Asked in

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

The optimal solution uses a greedy approach: sort all cuts by cost in descending order, then process them from most expensive to least expensive. When making a cut, multiply its cost by the current number of pieces it affects. This works because expensive cuts should be made early when they affect fewer pieces, minimizing the total cost. Time complexity: O((m+n) log(m+n)).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Optimal)	O((m + n) log (m + n))	O(m + n)	Sort cuts by cost descending, always make the most expensive available cut first
Dynamic Programming (Recursive with Memoization)	O(m³ × n³)	O(m² × n²)	Try all possible cuts recursively and memoize results

Greedy Approach (Optimal) — Algorithm Steps

Create combined list of all cuts with their costs and types (horizontal/vertical)
Sort all cuts in descending order by cost
Initialize counters for horizontal and vertical pieces (both start at 1)
Process cuts in order: for each cut, multiply its cost by current piece count
When making a horizontal cut, increment vertical piece count
When making a vertical cut, increment horizontal piece count
Sum all the costs to get minimum total

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort all cuts by cost

Arrange cuts from most expensive to least expensive

Make expensive cuts first

When fewer pieces exist, expensive cuts cost less overall

Track piece multiplication

Each cut multiplies its cost by current piece count

Sum total costs

Add up all the multiplied costs for final answer

Code -

solution.c — C

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

typedef struct {
    int cost;
    char cutType;
    int index;
} Cut;

int compareCuts(const void* a, const void* b) {
    Cut* cutA = (Cut*)a;
    Cut* cutB = (Cut*)b;
    return cutB->cost - cutA->cost; // Descending order
}

int minimumCost(int m, int n, int* horizontalCut, int horizontalCutSize, int* verticalCut, int verticalCutSize) {
    // Combine all cuts
    Cut* cuts = (Cut*)malloc((horizontalCutSize + verticalCutSize) * sizeof(Cut));
    int cutIndex = 0;
    
    for (int i = 0; i < horizontalCutSize; i++) {
        cuts[cutIndex++] = (Cut){horizontalCut[i], 'h', i};
    }
    for (int j = 0; j < verticalCutSize; j++) {
        cuts[cutIndex++] = (Cut){verticalCut[j], 'v', j};
    }
    
    // Sort by cost in descending order
    qsort(cuts, horizontalCutSize + verticalCutSize, sizeof(Cut), compareCuts);
    
    // Track number of pieces in each direction
    int hPieces = 1;
    int vPieces = 1;
    long long totalCost = 0;
    
    for (int i = 0; i < horizontalCutSize + verticalCutSize; i++) {
        if (cuts[i].cutType == 'h') {
            // Horizontal cut affects all vertical strips
            totalCost += (long long)cuts[i].cost * vPieces;
            hPieces++;
        } else {
            // Vertical cut affects all horizontal strips
            totalCost += (long long)cuts[i].cost * hPieces;
            vPieces++;
        }
    }
    
    free(cuts);
    return (int)totalCost;
}

int main() {
    // Input parsing and function call would go here
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m + n) log (m + n))

Sorting the cuts dominates, then O(m + n) to process them

⚡ Linearithmic

Space Complexity

O(m + n)

Store all cuts in a combined array for sorting

⚡ Linearithmic Space

28.9K Views

Medium Frequency

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

Greedy Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler