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

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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; 

      chevron_right

      
      

      Java

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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

      chevron_right

      
      

      Python3

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      # 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

      chevron_right

      
      

      C#

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // 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

      chevron_right

      
      

      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

      Recommended Posts:


      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.