Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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 <bits/stdc++.h>
      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)


Last Updated : 13 Sep, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads