Rod Cutting Problem in C++

The Rod Cutting Problem is a classic dynamic programming problem where a rod of length N and a list of prices for smaller pieces of rod is given, and the task is to determine the maximum value obtainable by cutting up the rod and selling the pieces. The length of the rod is taken as the size of the price array.

Example

Input: prices[] = {1, 5, 8, 9, 10, 17, 17, 20}
Output: 22
Explanation: By cutting the rod into two pieces of length 2 and 6, we get a maximum price of 5 + 17 = 22.

Input: prices[] = {2, 5, 7, 8, 10}
Output: Maximum obtainable price = 12
Explanation: By cutting the rod into two pieces of length 2 and 3, we get a maximum price of 5 + 7 = 12.

In C++, rod cutting problem can be solved using the following methods:

More methods to solve the rod cutting problem are given here - Rod Cutting

Using Recursion

In this approach, we recursively compute the maximum price by trying all possible cuts at each step.

• The basic idea is to cut into two pieces: one of length i and the other of length (n - i) where i is from 1 to n.
• Then compute the sum of the price of the piece of length i and the maximum price obtainable from the remaining rod (n - i).
• We repeat this for all lengths i and return the maximum value.

Code Implementation

// C++ program to solve the Rod Cutting Problem using recursion
#include <bits/stdc++.h>

using namespace std;

int cutRod(vector<int>& prices, int n) {
  
    // Base case: when rod length is 0, the price is 0
    if (n == 0) return 0;

    // Initialize maximum value
    int res = 0;

    // Try all possible cuts and recursively get the best price
    for (int i = 1; i <= n; i++) {
        // Recursively calculate the maximum obtainable price
        res = max(res, prices[i - 1] + cutRod(prices, n - i));
    }

    return res;
}

int main() {
  
    // Prices array
    vector<int> prices = {1, 5, 8, 9, 10, 17, 17, 20};
  	int rodLength = prices.size();

    // Calculate and print the maximum obtainable price
    cout << cutRod(prices, rodLength) << endl;

    return 0;
}

22

Time Complexity: Exponential
Space Complexity: O(n) where n is the length of the price array.

This method has exponential time complexity because it leads to many redundant calculations.

Using Dynamic Programming

The cutting rod problem is ideally solved using dynamic programming due to redundant calculation. We use a to store the maximum obtainable price for each length when calculated for the first time. After that, we refer to this table instead of calculating the price again.

Code Implementation

// C++ program to solve the Rod Cutting Problem
#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int cutRod(vector<int>& prices, int n) {
  
    // dp[] will store the maximum price
  	// obtainable for each length
    vector<int> dp(n + 1, 0);

    // Build the dp array
    for (int i = 1; i <= n; i++) {
        int res = 0;
      
        // Try all possible cuts
        for (int j = 0; j < i; j++) {
            res = max(res, prices[j]
                          + dp[i - j - 1]);
        }
        dp[i] = res;
    }

    // Maximum price obtainable for rod length
    // n will be at dp[n]
    return dp[n];
}

int main() {
  
    // Prices array
    vector<int> prices = {1, 5, 8, 9, 10,
                          17, 17, 20};
    int rodLength = prices.size();

    // Calculate and print the maximum
    // obtainable price
    cout << cutRod(prices, rodLength) << endl;

    return 0;
}

22

Time Complexity: O(n²), where n is the length of the price array.
Space Complexity: O(n)