Maximise number of cuts in a rod if it can be cut only in given 3 sizes
Last Updated :
13 Sep, 2023
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)
Share your thoughts in the comments
Please Login to comment...