# 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.

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(N

2

)

Auxiliary Space:

O(1)

Efficient Approach:

The problem can be solve using Dynamic Programming.

1. Create 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]))
1. Here is the implementation of the above approach:
2. ## 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`

## Javascript

 `// A Dynamic Programming solution for ``// Maximum Rod cutting problem ` `// function that eturns the maximum ``// number of rods that can be ``// made from the rod of length N ``const cuttingRod = (arr, N) => {``    ``const dp = ``new` `Array(N + 1);``    ` `    ``// Initializing the number of rods we ``    ``// can make from length 0 ``    ``dp[0] = 0;``    ` `    ``// Iterating over lengths that can ``    ``// be formed ``    ``for` `(let i = 1; i <= N; i++) {``        ` `        ``// Initializing the possible ``        ``// cuts as infinite ``        ``dp[i] = Number.MIN_SAFE_INTEGER;``        ` `         ``// Cutting the desired lengths ``        ``for` `(let 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]] !== Number.MIN_SAFE_INTEGER) {``                ` `                ``// 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 ``const N = 17;``const arr = [10, 11, 3];``console.log(cuttingRod(arr, N));`

3. Output
```3

```
4. Time Complexity:
5. O (N)
6. Auxiliary Space:
7. O (N)

Previous
Next