Minimum Cost for Cutting Cake II - Practice Coding Problems

Minimum Cost for Cutting Cake II - Problem

Imagine you're a professional baker with a beautiful m × n rectangular cake that needs to be cut into individual 1 × 1 pieces for serving. However, each cut comes with a cost!

The Challenge: You have two types of cuts available:

Horizontal cuts: Cut along any horizontal line i at cost horizontalCut[i]
Vertical cuts: Cut along any vertical line j at cost verticalCut[j]

Key insight: When you make a cut, it affects ALL pieces that cross that line. For example, if you've already made some vertical cuts creating multiple columns, a horizontal cut will cost the same but will cut through ALL those columns simultaneously!

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

Input: Dimensions m, n, and arrays horizontalCut (size m-1) and verticalCut (size n-1) representing cut costs.

Output: Minimum total cost as an integer.

Input & Output

example_1.py — Small Cake

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

› Output: 13

💡 Note: Sort cuts: [5(V), 3(H), 1(H)]. Cost = 5×1 + 3×2 + 1×2 = 5+6+2 = 13. The expensive vertical cut (5) is made first when it only affects 1 piece, then horizontal cuts affect 2 pieces each.

example_2.py — Larger Example

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

› Output: 54

💡 Note: Sorted cuts: [7(V), 6(H), 4(H), 2(V), 2(H), 1(V)]. Processing: 7×1=7, 6×2=12, 4×2=8, 2×3=6, 2×3=6, 1×4=4. Total = 54. Notice how later cuts have higher multipliers.

example_3.py — Edge Case

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

› Output: 15

💡 Note: Only two cuts needed. Sort: [7(H), 4(V)]. Cost = 7×1 + 4×2 = 7+8 = 15. The horizontal cut goes first, then vertical cut affects 2 horizontal pieces.

Constraints

1 ≤ m, n ≤ 10⁵
horizontalCut.length == m - 1
verticalCut.length == n - 1
1 ≤ horizontalCut[i], verticalCut[i] ≤ 10⁶
The answer may be large, consider using long long in C++

Visualization

Tap to expand

Understanding the Visualization

Identify All Cuts

List all possible horizontal and vertical cuts with their costs

Sort by Cost

Arrange cuts from most expensive to least expensive

Cut Greedily

Always make the most expensive remaining cut first

Calculate Multiplier

Each cut affects all perpendicular pieces created so far

Key Takeaway

🎯 Key Insight: The greedy approach works because making expensive cuts first minimizes their multiplication factor, leading to the optimal total cost.

Asked in

G Google 85 f Meta 72 a Amazon 68 ⊞ Microsoft 45 Apple 31

The optimal solution uses a greedy approach with sorting. Key insight: expensive cuts should be made early when they affect fewer pieces. Sort all cuts by cost descending, then process greedily. Each cut's cost = cut_cost × (perpendicular_cuts + 1). Time complexity: O((m+n) log(m+n)).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Cut Sequences)	O((m+n)!)	O(m+n)	Try every possible order of cuts and find minimum cost
Greedy Approach (Optimal)	O((m+n) log(m+n))	O(m+n)	Sort cuts by cost descending, always choose the most expensive remaining cut first

Brute Force (Try All Cut Sequences) — Algorithm Steps

Generate all possible cut sequences
For each sequence, simulate the cutting process
Track how many pieces each cut affects
Calculate total cost for each sequence
Return the minimum cost found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Sequences

Create all possible orderings of horizontal and vertical cuts

Simulate Each Sequence

For each sequence, track how cuts multiply across existing pieces

Calculate Total Cost

Sum up costs considering the multiplier effect of previous cuts

Find Minimum

Compare all sequences and return the minimum cost

Code -

solution.c — C

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

typedef struct {
    int type; // 0 for horizontal, 1 for vertical
    int cost;
} Cut;

long long findMinCost(Cut* cuts, int* used, int totalCuts, int made, int hCuts, int vCuts) {
    if (made == totalCuts) return 0;
    
    long long minCost = LLONG_MAX;
    
    for (int i = 0; i < totalCuts; i++) {
        if (used[i]) continue;
        
        used[i] = 1;
        long long cost;
        
        if (cuts[i].type == 0) { // horizontal
            cost = (long long)cuts[i].cost * (vCuts + 1);
            cost += findMinCost(cuts, used, totalCuts, made + 1, hCuts + 1, vCuts);
        } else { // vertical
            cost = (long long)cuts[i].cost * (hCuts + 1);
            cost += findMinCost(cuts, used, totalCuts, made + 1, hCuts, vCuts + 1);
        }
        
        if (cost < minCost) minCost = cost;
        used[i] = 0;
    }
    
    return minCost;
}

long long minimumCost(int m, int n, int* horizontalCut, int* verticalCut) {
    int totalCuts = (m-1) + (n-1);
    Cut* cuts = (Cut*)malloc(totalCuts * sizeof(Cut));
    int* used = (int*)calloc(totalCuts, sizeof(int));
    
    int idx = 0;
    for (int i = 0; i < m-1; i++) {
        cuts[idx++] = (Cut){0, horizontalCut[i]};
    }
    for (int i = 0; i < n-1; i++) {
        cuts[idx++] = (Cut){1, verticalCut[i]};
    }
    
    long long result = findMinCost(cuts, used, totalCuts, 0, 0, 0);
    
    free(cuts);
    free(used);
    return result;
}

int main() {
    int m, n;
    scanf("%d %d", &m, &n);
    
    int* horizontalCut = (int*)malloc((m-1) * sizeof(int));
    int* verticalCut = (int*)malloc((n-1) * sizeof(int));
    
    for (int i = 0; i < m-1; i++) {
        scanf("%d", &horizontalCut[i]);
    }
    
    for (int i = 0; i < n-1; i++) {
        scanf("%d", &verticalCut[i]);
    }
    
    printf("%lld\n", minimumCost(m, n, horizontalCut, verticalCut));
    
    free(horizontalCut);
    free(verticalCut);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((m+n)!)

We need to try all permutations of m-1 + n-1 cuts

✓ Linear Growth

Space Complexity

O(m+n)

Space for recursion stack and storing current sequence

⚡ Linearithmic Space

43.2K Views

Medium-High Frequency

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

Brute Force (Try All Cut Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler