Rod Cutting Problem - Problem

You are given a rod of length N and an array of prices where prices[i] represents the price you can get for selling a rod piece of length i+1.

Your task is to determine the maximum revenue you can obtain by cutting the rod into pieces and selling them. You can make any number of cuts, and each piece must have an integer length.

Example: If the rod has length 4 and prices = [1, 5, 8, 9], you can:

Sell as one piece of length 4: revenue = 9
Cut into pieces of length 1+3: revenue = 1 + 8 = 9
Cut into pieces of length 2+2: revenue = 5 + 5 = 10
Cut into pieces of length 1+1+2: revenue = 1 + 1 + 5 = 7
Cut into pieces of length 1+1+1+1: revenue = 1 + 1 + 1 + 1 = 4

The maximum revenue is 10.

Input & Output

Example 1 — Basic Rod Cutting

$ Input: prices = [1,5,8,9], n = 4

› Output: 10

💡 Note: Cut rod into two pieces of length 2 each. Revenue = prices[1] + prices[1] = 5 + 5 = 10. This is better than keeping it whole (9) or other combinations.

Example 2 — Keep Whole Rod

$ Input: prices = [1,5,8,20], n = 4

› Output: 20

💡 Note: Best strategy is to keep the rod whole and sell for prices[3] = 20. Any cuts would result in lower revenue.

Example 3 — All Unit Cuts

$ Input: prices = [3,1,1,1], n = 4

› Output: 12

💡 Note: Cut into 4 pieces of length 1 each. Revenue = 3 + 3 + 3 + 3 = 12. Unit pieces give highest price per unit length.

Constraints

1 ≤ n ≤ 1000
1 ≤ prices.length ≤ n
1 ≤ prices[i] ≤ 1000

Visualization

Tap to expand

Asked in

G Google 35 a Amazon 28 M Microsoft 22 f Facebook 18

The key insight is that this problem exhibits optimal substructure - the optimal way to cut a rod of length n depends on optimal solutions for smaller lengths. The best approach is bottom-up dynamic programming which builds the solution iteratively from length 1 to n. Time: O(n²), Space: O(n).

Common Approaches

✓ Bottom-Up Dynamic Programming

⏱️ Time: O(n²) Space: O(n)

Create a DP table where dp[i] represents maximum revenue for rod of length i. Fill the table bottom-up using previously computed values.

Memoized Recursion

⏱️ Time: O(n²) Space: O(n)

Same recursive approach but store results of subproblems in a memoization table to avoid recalculating the same rod lengths.

Recursive Brute Force

⏱️ Time: O(2^n) Space: O(n)

For each position, try making a cut and recursively solve for the remaining piece. Compare with not making any cuts.

Bottom-Up Dynamic Programming — Algorithm Steps

Step 1: Create DP array of size n+1, initialize dp[0] = 0
Step 2: For each length i from 1 to n, try all possible first cuts
Step 3: dp[i] = max(prices[j-1] + dp[i-j]) for all valid j
Step 4: Return dp[n] as the maximum revenue

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize DP table

Create array with dp[0] = 0

Fill table bottom-up

For each length, try all possible first cuts

Return final answer

dp[n] contains maximum revenue

Code -

solution.c — C

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

int solution(int* prices, int pricesSize, int n) {
    int* dp = (int*)calloc(n + 1, sizeof(int));
    
    for (int i = 1; i <= n; i++) {
        int maxLen = pricesSize < i ? pricesSize : i;
        
        for (int j = 1; j <= maxLen; j++) {
            int val = prices[j-1] + dp[i-j];
            if (val > dp[i]) dp[i] = val;
        }
    }
    
    int result = dp[n];
    free(dp);
    return result;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int prices[100];
    int pricesSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            prices[pricesSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int n;
    scanf("%d", &n);
    
    int result = solution(prices, pricesSize, n);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(n)

DP array of size n+1 to store maximum revenue for each length

⚡ Linearithmic Space

34.5K Views

High Frequency

~25 min Avg. Time

892 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

Rod Cutting Problem - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Bottom-Up Dynamic Programming — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler