Open In App
Related Articles

Maximum number of segments of lengths a, b and c

Improve Article
Improve
Save Article
Save
Like Article
Like

Given a positive integer N, find the maximum number of segments of lengths a, b and c that can be formed from N . 
Examples : 
 

Input : N = 7, a = 5, b, = 2, c = 5 
Output : 2 
N can be divided into 2 segments of lengths
2 and 5. For the second example,

Input : N = 17, a = 2, b = 1, c = 3 
Output : 17 
N can be divided into 17 segments of 1 or 8 
segments of 2 and 1 segment of 1. But 17 segments
of 1 is greater than 9 segments of 2 and 1.  

 

To understand any DP problem clearly, we need to write first of all its recursive code and then go for optimization.

Recursion-Based Solution:

Here for any value of n, we have 3 possibilities, for making the maximum segment count
if (n >= a) we can make 1 segment of length a + another possible segment from the length of n - a
if (n >= b) we can make 1 segment of length b + another possible segment from the length of n - b
if (n >= c) we can make 1 segment of length c + another possible segment from the length of n - c
so now we have to take the maximum possible segment above in 3 condition

Below is an implementation for the same.

C++




// C++ implementation to divide N into maximum
// number of segments of length a, b and c
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the maximum number
// of segments
int maximumSegments(int n, int a, int b, int c)
{
    // Base case
    if (n == 0) {
        return 0;
    }
 
    int maxa = INT_MIN;
    // Conditions
 
    // Making one segment of length a
    if (n >= a) {
        maxa = max(maxa,
                   1 + maximumSegments(n - a, a, b, c));
    }
    // Making one segment of length b
    if (n >= b) {
        maxa = max(maxa,
                   1 + maximumSegments(n - b, a, b, c));
    }
    // Making one segment of length c
    if (n >= c) {
        maxa = max(maxa,
                   1 + maximumSegments(n - c, a, b, c));
    }
 
    // Return maximum out of all possible segment
    return maxa;
}
 
// Driver code
int main()
{
    int n = 7, a = 5, b = 2, c = 5;
 
    // Function call
    cout << maximumSegments(n, a, b, c);
    return 0;
}


Java




// Java implementation to divide N into
// maximum number of segments of length a, b and c
 
class GFG {
 
  static int INT_MIN = -1000000000;
 
  // Function to find the maximum number of segments
  static int maximumSegments(int n, int a, int b, int c)
  {
 
    // Base case
    if (n == 0) {
      return 0;
    }
 
    int maxa = INT_MIN;
    // Conditions
 
    // Making one segment of length a
    if (n >= a) {
      maxa = Math.max(maxa, 1 + maximumSegments(n - a, a, b, c));
    }
    // Making one segment of length b
    if (n >= b) {
      maxa = Math.max(maxa, 1 + maximumSegments(n - b, a, b, c));
    }
    // Making one segment of length c
    if (n >= c) {
      maxa = Math.max(maxa, 1 + maximumSegments(n - c, a, b, c));
    }
 
    // Return maximum out of all possible segment
    return maxa;
  }
 
  // Driver code
  public static void main(String[] args) {
    int n = 7, a = 5, b = 2, c = 5;
 
    // Function call
    System.out.println(maximumSegments(n, a, b, c));
  }
}
 
// This code is contributed by ajaymakvana.


Python




# Python implementation to divide N into maximum
# number of segments of length a, b and c
 
# Function to find the maximum number
# of segments
def maximumSegments(n, a, b, c):
    # Base case
    if n == 0:
        return 0
 
    maxa = float('-inf')
    # Conditions
 
    # Making one segment of length a
    if n >= a:
        maxa = max(maxa,
                   1 + maximumSegments(n - a, a, b, c))
    # Making one segment of length b
    if n >= b:
        maxa = max(maxa,
                   1 + maximumSegments(n - b, a, b, c))
    # Making one segment of length c
    if n >= c:
        maxa = max(maxa,
                   1 + maximumSegments(n - c, a, b, c))
 
    # Return maximum out of all possible segment
    return maxa
 
# Driver code
if __name__ == '__main__':
    n = 7
    a = 5
    b = 2
    c = 5
 
    # Function call
    print(maximumSegments(n, a, b, c))
 
 # This code is contributed by divyansh2212


C#




using System;
 
namespace ConsoleApp {
  class Program {
    static void Main(string[] args)
    {
      int n = 7, a = 5, b = 2, c = 5;
      Console.WriteLine(maximumSegments(n, a, b, c));
    }
 
    // Function to find the maximum number of segments
    static int maximumSegments(int n, int a, int b, int c)
    {
      // Base case
      if (n == 0) {
        return 0;
      }
 
      int maxa = int.MinValue;
      // Conditions
 
      // Making one segment of length a
      if (n >= a) {
        maxa = Math.Max(
          maxa, 1 + maximumSegments(n - a, a, b, c));
      }
      // Making one segment of length b
      if (n >= b) {
        maxa = Math.Max(
          maxa, 1 + maximumSegments(n - b, a, b, c));
      }
      // Making one segment of length c
      if (n >= c) {
        maxa = Math.Max(
          maxa, 1 + maximumSegments(n - c, a, b, c));
      }
 
      // Return maximum out of all possible segments
      return maxa;
    }
  }
}
 
// This code is contributed by divyansh2212


Javascript




// Javascript implementation to divide N into maximum
// number of segments of length a, b and c
 
// Function to find the maximum number
// of segments
function maximumSegments(n, a, b, c) {
    // Base case
    if (n === 0) {
        return 0;
    }
 
    let maxa = Number.MIN_SAFE_INTEGER;
 
    // Making one segment of length a
    if (n >= a) {
        maxa = Math.max(maxa,
                   1 + maximumSegments(n - a, a, b, c));
    }
    // Making one segment of length b
    if (n >= b) {
        maxa = Math.max(maxa,
                   1 + maximumSegments(n - b, a, b, c));
    }
    // Making one segment of length c
    if (n >= c) {
        maxa = Math.max(maxa,
                   1 + maximumSegments(n - c, a, b, c));
    }
 
    // Return maximum out of all possible segment
    return maxa;
}
 
// Driver code
let n = 7, a = 5, b = 2, c = 5;
 
// Function call
console.log(maximumSegments(n, a, b, c));
 
// This code is contributed by poojaagarwal2.


Output

2

Time Complexity: O(3n)
Auxiliary Space : O(n)

Optimized Approach : The approach used is Dynamic Programming. The base dp0 will be 0 as initially it has no segments. After that, iterate from 1 to n, and for each of the 3 states i.e, dpi+a, dpi+b and dpi+c, store the maximum value obtained by either using or not using the a, b or c segment. 
The 3 states to deal with are : 
 

dpi+a=max(dpi+1, dpi+a); 
dpi+b=max(dpi+1, dpi+b); 
dpi+c=max(dpi+1, dpi+c);

Below is the implementation of above idea : 
 

C++




// C++ implementation to divide N into
// maximum number of segments
// of length a, b and c
#include <bits/stdc++.h>
using namespace std;
 
// function to find the maximum
// number of segments
int maximumSegments(int n, int a, int b, int c)
{
    // stores the maximum number of
    // segments each index can have
    int dp[n + 1];
 
    // initialize with -1
    memset(dp, -1, sizeof(dp));
 
    // 0th index will have 0 segments
    // base case
    dp[0] = 0;
 
    // traverse for all possible
    // segments till n
    for (int i = 0; i < n; i++) {
        if (dp[i] != -1) {
 
            // conditions
            if (i + a <= n) // avoid buffer overflow
                dp[i + a] = max(dp[i] + 1, dp[i + a]);
 
            if (i + b <= n) // avoid buffer overflow
                dp[i + b] = max(dp[i] + 1, dp[i + b]);
 
            if (i + c <= n) // avoid buffer overflow
                dp[i + c] = max(dp[i] + 1, dp[i + c]);
        }
    }
    return dp[n];
}
 
// Driver code
int main()
{
    int n = 7, a = 5, b = 2, c = 5;
    cout << maximumSegments(n, a, b, c);
    return 0;
}


Java




// Java implementation to divide N into
// maximum number of segments
// of length a, b and c
import java.util.*;
 
class GFG
{
     
    // function to find the maximum
    // number of segments
    static int maximumSegments(int n, int a,
                            int b, int c)
    {
        // stores the maximum number of
        // segments each index can have
        int dp[] = new int[n + 10];
 
        // initialize with -1
        Arrays.fill(dp, -1);
 
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
 
        // traverse for all possible
        // segments till n
        for (int i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
 
                // conditions
                if(i + a <= n )    //avoid buffer overflow
                dp[i + a] = Math.max(dp[i] + 1,
                                    dp[i + a]);
                                     
                if(i + b <= n )    //avoid buffer overflow
                dp[i + b] = Math.max(dp[i] + 1,    
                                    dp[i + b]);
                                     
                if(i + c <= n )    //avoid buffer overflow
                dp[i + c] = Math.max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
 
    // Driver code
    public static void main(String arg[])
    {
        int n = 7, a = 5, b = 2, c = 5;
        System.out.print(maximumSegments(n, a, b, c));
    }
}
 
// This code is contributed by Anant Agarwal.


Python3




# Python implementation
# to divide N into maximum
# number of segments of
# length a, b and c
 
# function to find
# the maximum number
# of segments
def maximumSegments(n, a, b, c) :
 
    # stores the maximum
    # number of segments
    # each index can have
    dp = [-1] * (n + 10)
 
    # 0th index will have
    # 0 segments base case
    dp[0] = 0
 
    # traverse for all possible
    # segments till n
    for i in range(0, n) :
     
        if (dp[i] != -1) :
         
            # conditions
            if(i + a <= n ): # avoid buffer overflow   
                dp[i + a] = max(dp[i] + 1,
                            dp[i + a])
                             
            if(i + b <= n ): # avoid buffer overflow   
                dp[i + b] = max(dp[i] + 1,
                            dp[i + b])
                             
            if(i + c <= n ): # avoid buffer overflow   
                dp[i + c] = max(dp[i] + 1,
                            dp[i + c])
 
    return dp[n]
 
# Driver code
n = 7
a = 5
b = 2
c = 5
print (maximumSegments(n, a,
                    b, c))
 
# This code is contributed by
# Manish Shaw(manishshaw1)


C#




// C# implementation to divide N into
// maximum number of segments
// of length a, b and c
using System;
 
class GFG
{
     
    // function to find the maximum
    // number of segments
    static int maximumSegments(int n, int a,
                            int b, int c)
    {
        // stores the maximum number of
        // segments each index can have
        int []dp = new int[n + 10];
 
        // initialize with -1
        for(int i = 0; i < n + 10; i++)
        dp[i]= -1;
         
 
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
 
        // traverse for all possible
        // segments till n
        for (int i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
 
                // conditions
                if(i + a <= n )    // avoid buffer overflow
                dp[i + a] = Math.Max(dp[i] + 1,
                                    dp[i + a]);
                                     
                if(i + b <= n )    // avoid buffer overflow
                dp[i + b] = Math.Max(dp[i] + 1,
                                    dp[i + b]);
                                     
                if(i + c <= n )    // avoid buffer overflow
                dp[i + c] = Math.Max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
 
    // Driver code
    public static void Main()
    {
        int n = 7, a = 5, b = 2, c = 5;
        Console.Write(maximumSegments(n, a, b, c));
    }
}
 
// This code is contributed by nitin mittal


PHP




<?php
// PHP implementation to divide
// N into maximum number of
// segments of length a, b and c
 
// function to find the maximum
// number of segments
function maximumSegments($n, $a,
                        $b, $c)
{
    // stores the maximum
    // number of segments
    // each index can have
    $dp = array();
 
    // initialize with -1
    for($i = 0; $i < $n + 10; $i++)
        $dp[$i]= -1;
     
 
    // 0th index will have
    // 0 segments base case
    $dp[0] = 0;
 
    // traverse for all possible
    // segments till n
    for ($i = 0; $i < $n; $i++)
    {
        if ($dp[$i] != -1)
        {
            // conditions
            if($i + $a <= $n )    // avoid buffer overflow
            $dp[$i + $a] = max($dp[$i] + 1,
                            $dp[$i + $a]);
                             
            if($i + $b <= $n )    // avoid buffer overflow
            $dp[$i + $b] = max($dp[$i] + 1,
                            $dp[$i + $b]);
                             
            if($i + $c <= $n )    // avoid buffer overflow
            $dp[$i + $c] = max($dp[$i] + 1,
                            $dp[$i + $c]);
        }
    }
    return $dp[$n];
}
 
// Driver code
$n = 7; $a = 5;
$b = 2; $c = 5;
echo (maximumSegments($n, $a,
                    $b, $c));
 
// This code is contributed by
// Manish Shaw(manishshaw1)
?>


Javascript




<script>
// JavaScript program implementation to divide N into
// maximum number of segments
// of length a, b and c
 
    // function to find the maximum
    // number of segments
    function maximumSegments(n, a, b, c)
    {
        // stores the maximum number of
        // segments each index can have
        let dp = [];
   
        // initialize with -1
        for(let i = 0; i < n + 10; i++)
        dp[i]= -1;
   
        // 0th index will have 0 segments
        // base case
        dp[0] = 0;
   
        // traverse for all possible
        // segments till n
        for (let i = 0; i < n; i++)
        {
            if (dp[i] != -1)
            {
   
                // conditions
                if(i + a <= n )    //avoid buffer overflow
                dp[i + a] = Math.max(dp[i] + 1,
                                    dp[i + a]);
                                       
                if(i + b <= n )    //avoid buffer overflow
                dp[i + b] = Math.max(dp[i] + 1,    
                                    dp[i + b]);
                                       
                if(i + c <= n )    //avoid buffer overflow
                dp[i + c] = Math.max(dp[i] + 1,
                                    dp[i + c]);
            }
        }
        return dp[n];
    }
   
 
// Driver Code
 
        let n = 7, a = 5, b = 2, c = 5;
        document.write(maximumSegments(n, a, b, c));
 
// This code is contributed by susmitakundugoaldanga.
</script>


Output

2

Time Complexity: O(N), as we are using a loop to traverse N times.
Auxiliary Space: O(N), as we are using extra space for dp array.


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 Jan, 2023
Like Article
Save Article
Previous
Next
Similar Reads
Complete Tutorials