# Maximise number of cuts in a rod if it can be cut only in given 3 sizes

Given a rod of length N meters, and the rod can be cut in only 3 sizes A, B and C. The task is to maximizes the number of cuts in rod. If it is impossible to make cut then print -1.

Examples:

Input: N = 17, A = 10, B = 11, C = 3
Output: 3
Explanation:
The maximum cut can be obtain after making 2 cut of length 3 and one cut of length 11.

Input: N = 10, A = 9, B = 7, C = 11
Output: -1
Explanation:
It is impossible to make any cut so output will be -1.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach:

• Let us assume x, y, and z numbers of rods of sizes A, B, and C respectively are cut. And this can be written as a linear equation: x*A + y*B + z*C = N
• Now, simply iterate over all possible value of x and y and compute z using (N – x*A + y*B) / c.
• If x*A + y*B + z*C = N, then it is one of the possible answers.
• Finally compute the maximum value of x + y + z.

Time Complexity: O(N2)
Auxiliary Space: O(1)

Efficient Approach: The problem can be solve using Dynamic Programming.

1. Ceate a dp[] array of size N and initialise all value to INT_MIN.
2. Set dp[0] = 0, as it will be base case for our approach.
3. Iterate from 1 to N and check if it is possible to make a cut of any of possible length i.e A, B and C, and update dp[i] to minimum of all.
4. dp[i] = min (dp[i], 1 + subresult)
where, subresult = min(dp[i – A], min(dp[i – B], dp[i – C]))

Here is the implementation of the above approach:

## C++

 `// A Dynamic Programming solution for  ` `// Maximum Rod cutting problem  ` ` `  `#include   ` `using` `namespace` `std;  ` ` `  `// function that eturns the maximum  ` `// number of rods that can be  ` `// made from the rod of length N  ` `int` `cuttingRod(``int` `arr[], ``int` `N)  ` `{  ` `    ``int` `dp[N + 1];  ` ` `  `    ``// Initializing the number of rods we  ` `    ``// can make from length 0  ` `    ``dp[0] = 0;  ` ` `  `    ``// Iterating over lengths that can  ` `    ``// be formed  ` `    ``for` `(``int` `i = 1; i <= N; i++) {  ` ` `  `        ``// Initializing the possible  ` `        ``// cuts as infinite  ` `        ``dp[i] = INT_MIN;  ` ` `  `        ``// Cutting the desired lengths  ` `        ``for` `(``int` `j = 0; j < 3; j++) {  ` ` `  `            ``// Checking whether the length of  ` `            ``// rod becomes 0 or if after cutting  ` `            ``// the rod, it becomes useless  ` `            ``if` `((i - arr[j]) >= 0  ` `                ``&& dp[i - arr[j]] != INT_MIN) {  ` ` `  `                ``// Choosing the maximum  ` `                ``// possible desired  ` `                ``// length cuts to be made  ` `                ``dp[i] = max(dp[i - arr[j]] + 1,  ` `                            ``dp[i]);  ` `            ``}  ` `        ``}  ` `    ``}  ` `    ``return` `dp[N];  ` `}  ` ` `  `// Driver code  ` `int` `main()  ` `{  ` `    ``int` `N = 17;  ` `    ``int` `arr[] = { 10, 11, 3 };  ` `    ``cout << cuttingRod(arr, N);  ` `    ``return` `0;  ` `}  `

## Java

 `// A Dynamic Programming solution for ` `// Maximum Rod cutting problem ` `class` `GFG{ ` ` `  `// Function that eturns the maximum ` `// number of rods that can be ` `// made from the rod of length N ` `static` `int` `cuttingRod(``int` `arr[], ``int` `N) ` `{ ` `    ``int` `[]dp = ``new` `int``[N + ``1``]; ` ` `  `    ``// Initializing the number of rods we ` `    ``// can make from length 0 ` `    ``dp[``0``] = ``0``; ` ` `  `    ``// Iterating over lengths that can ` `    ``// be formed ` `    ``for``(``int` `i = ``1``; i <= N; i++) ` `    ``{ ` `         `  `        ``// Initializing the possible ` `        ``// cuts as infinite ` `        ``dp[i] = Integer.MIN_VALUE; ` ` `  `        ``// Cutting the desired lengths ` `        ``for``(``int` `j = ``0``; j < ``3``; j++) ` `        ``{ ` `             `  `            ``// Checking whether the length of  ` `            ``// rod becomes 0 or if after cutting  ` `            ``// the rod, it becomes useless  ` `            ``if` `((i - arr[j]) >= ``0` `&&  ` `              ``dp[i - arr[j]] != Integer.MIN_VALUE)  ` `            ``{ ` `                 `  `                ``// Choosing the maximum ` `                ``// possible desired ` `                ``// length cuts to be made ` `                ``dp[i] = Math.max(dp[i - arr[j]] + ``1``, ` `                                 ``dp[i]); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `dp[N]; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `N = ``17``; ` `    ``int` `arr[] = { ``10``, ``11``, ``3` `}; ` `     `  `    ``System.out.print(cuttingRod(arr, N)); ` `} ` `} ` ` `  `// This code is contributed by Princi Singh `

## Python3

 `# A Dynamic Programming solution for ` `# Maximum Rod cutting problem ` `import` `sys ` ` `  `# Function that returns the maximum ` `# number of rods that can be ` `# made from the rod of length N ` `def` `cuttingRod(arr, N): ` ` `  `    ``dp ``=` `(N ``+` `1``) ``*` `[``0``] ` ` `  `    ``# Initializing the number of rods we ` `    ``# can make from length 0 ` `    ``dp[``0``] ``=` `0` ` `  `    ``# Iterating over lengths that can ` `    ``# be formed ` `    ``for` `i ``in` `range` `(``1``, N ``+` `1``): ` ` `  `        ``# Initializing the possible ` `        ``# cuts as infinite ` `        ``dp[i] ``=` `-``sys.maxsize ``-` `1` ` `  `        ``# Cutting the desired lengths ` `        ``for` `j ``in` `range``(``3``): ` ` `  `            ``# Checking whether the length of ` `            ``# rod becomes 0 or if after cutting ` `            ``# the rod, it becomes useless ` `            ``if` `((i ``-` `arr[j]) >``=` `0` `and` `              ``dp[i ``-` `arr[j]] !``=` `-``sys.maxsize``-``1``): ` ` `  `                ``# Choosing the maximum ` `                ``# possible desired ` `                ``# length cuts to be made ` `                ``dp[i] ``=` `max``(dp[i ``-` `arr[j]] ``+` `1``, ` `                            ``dp[i]) ` `    ``return` `dp[N] ` ` `  `# Driver code ` `if` `__name__ ``=``=` `"__main__"``: ` ` `  `    ``N ``=` `17` `    ``arr ``=` `[ ``10``, ``11``, ``3` `] ` `     `  `    ``print``(cuttingRod(arr, N)) ` ` `  `# This code is contributed by chitranayal `

## C#

 `// A Dynamic Programming solution for ` `// Maximum Rod cutting problem ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function that eturns the maximum ` `// number of rods that can be ` `// made from the rod of length N ` `static` `int` `cuttingRod(``int``[] arr, ``int` `N) ` `{ ` `    ``int` `[]dp = ``new` `int``[N + 1]; ` ` `  `    ``// Initializing the number of rods we ` `    ``// can make from length 0 ` `    ``dp[0] = 0; ` ` `  `    ``// Iterating over lengths that can ` `    ``// be formed ` `    ``for``(``int` `i = 1; i <= N; i++) ` `    ``{ ` `         `  `        ``// Initializing the possible ` `        ``// cuts as infinite ` `        ``dp[i] = Int32.MinValue; ` ` `  `        ``// Cutting the desired lengths ` `        ``for``(``int` `j = 0; j < 3; j++) ` `        ``{ ` `             `  `            ``// Checking whether the length of  ` `            ``// rod becomes 0 or if after cutting  ` `            ``// the rod, it becomes useless  ` `            ``if` `((i - arr[j]) >= 0 &&  ` `              ``dp[i - arr[j]] != Int32.MinValue)  ` `            ``{ ` `                 `  `                ``// Choosing the maximum ` `                ``// possible desired ` `                ``// length cuts to be made ` `                ``dp[i] = Math.Max(dp[i - arr[j]] + 1, ` `                                 ``dp[i]); ` `            ``} ` `        ``} ` `    ``} ` `    ``return` `dp[N]; ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `N = 17; ` `    ``int``[] arr = { 10, 11, 3 }; ` `     `  `    ``Console.Write(cuttingRod(arr, N)); ` `} ` `} ` ` `  `// This code is contributed by code_hunt `

Output:

```3
```

Time Complexity: O (N)
Auxiliary Space: O (N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.