Minimum Cost to Cut a Stick

Minimum Cost to Cut a Stick - Problem

Given a wooden stick of length n units. The stick is labelled from 0 to n. For example, a stick of length 6 is labelled as follows:

[0] --- [1] --- [2] --- [3] --- [4] --- [5] --- [6]

Given an integer array cuts where cuts[i] denotes a position you should perform a cut at.

You should perform the cuts in order, you can change the order of the cuts as you wish.

The cost of one cut is the length of the stick to be cut, the total cost is the sum of costs of all cuts. When you cut a stick, it will be split into two smaller sticks (i.e. the sum of their lengths is the length of the stick before the cut).

Return the minimum total cost of the cuts.

Input & Output

Example 1 — Basic Case

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

› Output: 16

💡 Note: One optimal order: cut at 5 (cost=7), then cut at 3 (cost=5), then cut at 4 (cost=2), then cut at 1 (cost=3). Total: 7+5+2+3=17. Better order exists with cost 16.

Example 2 — Single Cut

$ Input: n = 9, cuts = [5]

› Output: 9

💡 Note: Only one cut at position 5, so the cost is the length of the entire stick: 9.

Example 3 — Two Cuts

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

› Output: 10

💡 Note: Cut at 2 first (cost=6), then cut at 4 in right piece [2,6] (cost=4). Total: 6+4=10. Or cut at 4 first (cost=6), then at 2 in left piece [0,4] (cost=4). Total: 6+4=10. Both orders give the same minimum cost of 10.

Constraints

2 ≤ n ≤ 10⁶
1 ≤ cuts.length ≤ min(n - 1, 100)
1 ≤ cuts[i] ≤ n - 1
All the integers in cuts array are distinct.

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Facebook 6

The key insight is that this is an interval DP problem where the cost depends on the current stick length. The optimal approach uses bottom-up dynamic programming with sorted cuts and boundary conditions. Time: O(m³), Space: O(m²).

Common Approaches

✓ Bottom-up Dynamic Programming

⏱️ Time: O(m³) Space: O(m²)

Create a 2D DP table where dp[i][j] represents the minimum cost to make all cuts between positions i and j. Fill the table bottom-up by considering all possible intermediate cuts.

Memoized Recursion

⏱️ Time: O(m³) Space: O(m²)

Use memoization to store results of cutting intervals. Sort cuts first and use indices to represent subproblems. Each subproblem represents cutting an interval between two positions.

Recursive with All Orders

⏱️ Time: O(m! × m²) Space: O(m)

For each remaining cut, recursively try making that cut first and take the minimum cost across all possibilities. This explores every possible ordering of cuts.

Bottom-up Dynamic Programming — Algorithm Steps

Sort cuts and add boundaries
Create 2D DP table
Fill table for increasing interval lengths
Try each possible intermediate cut position

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Table

Create dp[m][m] table for all interval pairs

Fill by Length

Process intervals in increasing order of length

Optimal Solution

Final answer is dp[0][m-1]

Code -

solution.c — C

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

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

int solution(int n, int* cuts, int cuts_size) {
    // Add boundaries and sort
    int sortedCuts[102];
    sortedCuts[0] = 0;
    for (int i = 0; i < cuts_size; i++) {
        sortedCuts[i + 1] = cuts[i];
    }
    sortedCuts[cuts_size + 1] = n;
    int m = cuts_size + 2;
    
    qsort(sortedCuts, m, sizeof(int), cmp);
    
    // DP table
    int dp[102][102];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            dp[i][j] = 0;
        }
    }
    
    // Fill DP table for increasing interval lengths
    for (int length = 3; length <= m; length++) {
        for (int i = 0; i <= m - length; i++) {
            int j = i + length - 1;
            dp[i][j] = INT_MAX;
            
            // Try all possible cuts between i and j
            for (int k = i + 1; k < j; k++) {
                int cost = sortedCuts[j] - sortedCuts[i];
                int total = cost + dp[i][k] + dp[k][j];
                if (total < dp[i][j]) {
                    dp[i][j] = total;
                }
            }
        }
    }
    
    return dp[0][m - 1];
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    int n;
    scanf("%d", &n);
    
    char line[1000];
    fgets(line, sizeof(line), stdin);
    fgets(line, sizeof(line), stdin);
    
    int cuts[100];
    int cuts_size = 0;
    
    char* token = strtok(line, "[],");
    while (token != NULL) {
        cuts[cuts_size++] = atoi(token);
        token = strtok(NULL, "[],");
    }
    
    int result = solution(n, cuts, cuts_size);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(m³)

Three nested loops: interval length, start position, and cut position

✓ Linear Growth

Space Complexity

O(m²)

2D DP table of size m×m where m is number of cuts plus boundaries

✓ Linear Space

125.0K Views

Medium Frequency

~35 min Avg. Time

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

Bottom-up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler