Given a rod of length n, find the optimal way to cut rod into smaller rods in order to maximize product of price of each of the smaller rod. Assume each rod of length i has price i.

**Best:** Cut the rod into two pieces of length 2 each

to gain revenue of 2*2 = 4

**Cut Profit**

4 4

1, 3 (1 * 3) = 3

**2, 2 (2 * 2) = 4**

3, 1 (3 * 1) = 3

1, 1, 2 (1 * 1 * 2) = 2

1, 2, 1 (1 * 2 * 1) = 2

2, 1, 1 (2 * 1 * 1) = 2

1, 1, 1, 1 (1 * 1 * 1 * 1) = 1

Similarly for n = 6, (3 * 3) = 9

For n = 8, (2 * 3 * 3) = 18

For n = 15, (3 * 3 * 3 * 3 * 3) = 243

The idea is very simple. We partition the given rod of length n into two parts of length i and n-i for each 1 <= i <= n. Then we recurse for rod of length n-i but don’t divide rod of length i any further. Finally, we take maximum of all values. This yields the below recursive relation –

rodcut(n) = max { n, i * rodCut(n – i) } where 1 <= i <= n

Below is C++ and Java implementation of the idea:

## C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
#include <iostream> #include <algorithm> using namespace std; // Function to find best way to cut a rod of length n // where rod of length i has price i int rodCut(int n) { // base case if (n <= 1) return n; // rod of length n has at-least cost of n int maxValue = n; // one by one partition the given rod of length n into two parts of // length (1, n-1), (2, n-2), .... (n-1 , 1), (n, 0) and take maximum for (int i = 1; i <= n; i++) maxValue = max(maxValue, i * rodCut(n - i)); return maxValue; } int main() { // n is rod length int n = 15; // 3x 5 times cout << "Maximum profit is " << rodCut(n); return 0; } |

`Output:`

Maximum Profit is 243

## Java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
class Util { // Function to find best way to cut a rod of length n // where rod of length i has price i public static int rodCut(int n) { // base case if (n <= 1) { return n; } // rod of length n has at-least cost of n int maxValue = n; // one by one partition the given rod of length n into // two parts of length (1, n-1), (2, n-2), .... // (n-1 , 1), (n, 0) and take maximum for (int i = 1; i <= n; i++) { maxValue = Integer.max(maxValue, i * rodCut(n - i)); } return maxValue; } // main function public static void main(String[] args) { int n = 15; // 3 x 5 times System.out.println(rodCut(n)); } } |

`Output:`

Maximum Profit is 243

The time complexity of above solution is O(n^{n}) and auxiliary space used by the program is O(1).

We have seen that the problem can be broken down into smaller subproblems which can further be broken down into yet smaller subproblems, and so on. So the problem has an optimal substructure. Let us consider recursion tree for rod of length 4.

As we can see, the same sub-problems (highlighted in same color) are getting computed again and again. So the problem also exhibits overlapping subproblems. We know that problems having optimal substructure and overlapping subproblems can be solved by dynamic programming, in which subproblem solutions are *Memo*ized rather than computed again and again.

We will solve this problem in bottom-up manner. In the bottom-up approach, we solve smaller sub-problems first, then solve larger sub-problems from them. The following bottom-up approach computes T[i], which stores maximum profit achieved from rod of length i for each 1 <= i <= n. It uses value of smaller values i already computed.

Below is C++ and Java implementation of the idea:

## C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
#include <iostream> #include <algorithm> using namespace std; int rodCut(int n) { // T[i] stores maximum profit achieved from rod of length i int T[n + 1]; // rod of len i has at-least cost i for (int i = 0; i <= n; i++) T[i] = i; // consider rod of length i for (int i = 2; i <= n; i++) { // divide the rod of length i into two rods of length j // and i-j each and take maximum for (int j = 1; j <= i; j++) T[i] = max(T[i], j * T[i - j]); } // T[n] stores maximum profit achieved from rod of length n return T[n]; } // main function int main() { // rod length int n = 15; cout << rodCut(n); return 0; } |

`Output:`

Maximum Profit is 243

## Java

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
class RodCut { // Function to find best way to cut a rod of length n // where rod of length i has a cost price[i-1] public static int rodCut(int[] price) { int n = price.length; // T[i] stores maximum profit achieved from rod of length i int[] T = new int[n + 1]; // consider rod of length i for (int i = 1; i <= n; i++) { // divide the rod of length i into two rods of length j // and i-j each and take maximum for (int j = 1; j <= i; j++) { T[i] = Integer.max(T[i], price[j - 1] + T[i - j]); } } // T[n] stores maximum profit achieved from rod of length n return T[n]; } // main function public static void main(String[] args) { // int[] length = { 1, 2, 3, 4, 5, 6, 7, 8 }; int[] price = { 1, 5, 8, 9, 10, 17, 17, 20 }; System.out.println("Profit is " + rodCut(price)); } } |

`Output:`

Maximum Profit is 243

The time complexity of above solution is O(n^{2}) and auxiliary space used by the program is O(n).

**Thanks for reading.**

Please use our online compiler to post code in comments. To contribute, get in touch with us.

Like us? Please spread the word and help us grow. Happy coding 🙂

## Leave a Reply

I think the iterative solution is for Maximum price for Rod cutting problem https://www.techiedelight.com/rot-cutting/.

Shouldn’t the solution for maximum product be different than maximum price rod cutting problem?

No, that is different and this one is correct!

int productRod(int n)

{

if(n = 0) return 3 * productRod(n – 3);

if(n – 2 != 1 && n – 2 >= 0) return 2 * productRod(n – 2);

return n;

}