Minimum Cost to Cut a Stick - Practice Coding Problems

Minimum Cost to Cut a Stick - Problem

The Wooden Stick Cutting Challenge

You have a wooden stick of length n units, labeled from position 0 to n. Imagine you're a carpenter who needs to make several cuts on this stick at specific positions given in the array cuts.

Here's the twist: the cost of each cut equals the length of the stick being cut. When you cut a stick, it splits into two smaller pieces, and the total length remains the same.

The key insight: You can choose the order of cuts to minimize the total cost! Different cutting sequences result in different costs because each cut operates on sticks of different lengths.

Goal: Find the minimum total cost to make all required cuts.

Example: For a stick of length 7 with cuts at [1,3,4,5]:
• One sequence might cost 7+6+4+3 = 20
• A better sequence might cost 7+4+3+2 = 16

Your task is to find the optimal cutting strategy!

Input & Output

example_1.py — Basic Case

$ Input: n = 7, cuts = [1,3,4,5]

› Output: 16

💡 Note: One optimal cutting sequence: First cut at position 5 (cost=7), then cut the left part [0,5] at position 3 (cost=5), then cut [3,5] at position 4 (cost=2), finally cut [0,3] at position 1 (cost=3). Total cost = 7+5+2+3 = 17. But there's a better sequence that costs 16.

example_2.py — Minimal Case

$ Input: n = 9, cuts = [5,6,1,4,2]

› Output: 22

💡 Note: For a stick of length 9 with 5 cuts, the optimal cutting strategy minimizes the cost by choosing the right order. The exact sequence depends on the dynamic programming calculation.

example_3.py — Edge Case

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

› Output: 12

💡 Note: When cuts are consecutive, the optimal strategy is often to cut from the middle outward to minimize the lengths of remaining segments.

Visualization

Tap to expand

Understanding the Visualization

Setup Boundaries

Add endpoints 0 and n to create a complete interval system

Build DP Table

Calculate minimum cost for each possible sub-interval

Optimal Substructure

Each interval's optimal cost builds from its sub-intervals

Key Takeaway

🎯 Key Insight: The problem has optimal substructure - the best way to cut any segment is independent of how we reached that segment, making Dynamic Programming the perfect approach!

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

n! permutations, each requiring O(n²) time to simulate the cutting process

⚠ Quadratic Growth

Space Complexity

O(n²)

Space for storing permutations and tracking stick segments during simulation

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 10⁶
1 ≤ cuts.length ≤ min(n - 1, 100)
1 ≤ cuts[i] ≤ n - 1
All values in cuts are unique
cuts[i] ≠ cuts[j] for i ≠ j

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses Interval Dynamic Programming with O(n³) time complexity. Add boundary points (0, n) to cuts, sort the array, then use DP where dp[i][j] represents minimum cost to cut between positions i and j. The key insight is that each subproblem is independent - the optimal way to cut any interval doesn't depend on how we got that interval, making this perfect for DP optimization.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Orders)	O(n! × n²)	O(n²)	Try all possible orders of cuts and return the minimum cost
Dynamic Programming (Optimal)	O(n³)	O(n²)	Use interval DP to find optimal cutting strategy for each segment

Brute Force (Try All Orders) — Algorithm Steps

Generate all permutations of the cuts array
For each permutation, simulate the cutting process
Track current stick segments and their lengths
Calculate cost for each cut based on the segment being cut
Return the minimum total cost among all permutations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Permutations

Create all possible orders of cuts [1,3,4,5]

Simulate Each Order

For each order, simulate cuts and calculate total cost

Track Minimum

Keep track of the minimum cost found so far

Code -

solution.c — C

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

int getCost(int n, int* cutOrder, int len) {
    int segments[100][2]; // assuming max 100 segments
    int segCount = 1;
    segments[0][0] = 0;
    segments[0][1] = n;
    int totalCost = 0;
    
    for (int c = 0; c < len; c++) {
        int cut = cutOrder[c];
        for (int i = 0; i < segCount; i++) {
            if (segments[i][0] < cut && cut < segments[i][1]) {
                int cost = segments[i][1] - segments[i][0];
                totalCost += cost;
                int oldEnd = segments[i][1];
                segments[i][1] = cut;
                segments[segCount][0] = cut;
                segments[segCount][1] = oldEnd;
                segCount++;
                break;
            }
        }
    }
    return totalCost;
}

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int minCostHelper(int n, int* cuts, int len, int start, int* minVal) {
    if (start == len) {
        int cost = getCost(n, cuts, len);
        if (cost < *minVal) {
            *minVal = cost;
        }
        return *minVal;
    }
    
    for (int i = start; i < len; i++) {
        swap(&cuts[start], &cuts[i]);
        minCostHelper(n, cuts, len, start + 1, minVal);
        swap(&cuts[start], &cuts[i]);
    }
    return *minVal;
}

int minCost(int n, int* cuts, int cutsSize) {
    int minVal = INT_MAX;
    return minCostHelper(n, cuts, cutsSize, 0, &minVal);
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n! × n²)

n! permutations, each requiring O(n²) time to simulate the cutting process

⚠ Quadratic Growth

Space Complexity

O(n²)

Space for storing permutations and tracking stick segments during simulation

⚠ Quadratic Space

Constraints

2 ≤ n ≤ 10⁶
1 ≤ cuts.length ≤ min(n - 1, 100)
1 ≤ cuts[i] ≤ n - 1
All values in cuts are unique
cuts[i] ≠ cuts[j] for i ≠ j

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Try All Orders) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler