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.
- Create a dp[] array of size N and initialise all value to INT_MIN.
- Set dp[0] = 0, as it will be base case for our approach.
- 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.
-
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++
#include <bits/stdc++.h>
using namespace std;
int cuttingRod( int arr[], int N)
{
int dp[N + 1];
dp[0] = 0;
for ( int i = 1; i <= N; i++) {
dp[i] = INT_MIN;
for ( int j = 0; j < 3; j++) {
if ((i - arr[j]) >= 0
&& dp[i - arr[j]] != INT_MIN) {
dp[i] = max(dp[i - arr[j]] + 1,
dp[i]);
}
}
}
return dp[N];
}
int main()
{
int N = 17;
int arr[] = { 10, 11, 3 };
cout << cuttingRod(arr, N);
return 0;
}
|
Java
class GFG{
static int cuttingRod( int arr[], int N)
{
int []dp = new int [N + 1 ];
dp[ 0 ] = 0 ;
for ( int i = 1 ; i <= N; i++)
{
dp[i] = Integer.MIN_VALUE;
for ( int j = 0 ; j < 3 ; j++)
{
if ((i - arr[j]) >= 0 &&
dp[i - arr[j]] != Integer.MIN_VALUE)
{
dp[i] = Math.max(dp[i - arr[j]] + 1 ,
dp[i]);
}
}
}
return dp[N];
}
public static void main(String[] args)
{
int N = 17 ;
int arr[] = { 10 , 11 , 3 };
System.out.print(cuttingRod(arr, N));
}
}
|
Python3
import sys
def cuttingRod(arr, N):
dp = (N + 1 ) * [ 0 ]
dp[ 0 ] = 0
for i in range ( 1 , N + 1 ):
dp[i] = - sys.maxsize - 1
for j in range ( 3 ):
if ((i - arr[j]) > = 0 and
dp[i - arr[j]] ! = - sys.maxsize - 1 ):
dp[i] = max (dp[i - arr[j]] + 1 ,
dp[i])
return dp[N]
if __name__ = = "__main__" :
N = 17
arr = [ 10 , 11 , 3 ]
print (cuttingRod(arr, N))
|
C#
using System;
class GFG{
static int cuttingRod( int [] arr, int N)
{
int []dp = new int [N + 1];
dp[0] = 0;
for ( int i = 1; i <= N; i++)
{
dp[i] = Int32.MinValue;
for ( int j = 0; j < 3; j++)
{
if ((i - arr[j]) >= 0 &&
dp[i - arr[j]] != Int32.MinValue)
{
dp[i] = Math.Max(dp[i - arr[j]] + 1,
dp[i]);
}
}
}
return dp[N];
}
public static void Main()
{
int N = 17;
int [] arr = { 10, 11, 3 };
Console.Write(cuttingRod(arr, N));
}
}
|
Javascript
const cuttingRod = (arr, N) => {
const dp = new Array(N + 1);
dp[0] = 0;
for (let i = 1; i <= N; i++) {
dp[i] = Number.MIN_SAFE_INTEGER;
for (let j = 0; j < 3; j++) {
if ((i - arr[j]) >= 0 && dp[i - arr[j]] !== Number.MIN_SAFE_INTEGER) {
dp[i] = Math.max(dp[i - arr[j]] + 1, dp[i]);
}
}
}
return dp[N];
}
const N = 17;
const arr = [10, 11, 3];
console.log(cuttingRod(arr, N));
|
-
- Time Complexity:
- O (N)
- Auxiliary Space:
- O (N)
Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!
Last Updated :
13 Sep, 2023
Like Article
Save Article