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.
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; } |
chevron_right
filter_none
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. |
chevron_right
filter_none
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 = 7a = 5b = 2c = 5print (maximumSegments(n, a, b, c)) # This code is contributed by # Manish Shaw(manishshaw1) |
chevron_right
filter_none
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 |
chevron_right
filter_none
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) ?> |
chevron_right
filter_none
Output :
2
Time complexity : 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.
Recommended Posts:
- Maximum length of segments of 0's and 1's
- Sum of lengths of all paths possible in a given tree
- Queries to count distinct Binary Strings of all lengths from N to M satisfying given properties
- Minimum splits required to convert a number into prime segments
- Count of ways to split a given number into prime segments
- Partition the array in K segments such that bitwise AND of individual segment sum is maximized
- LCS formed by consecutive segments of at least length K
- Divide the array in K segments such that the sum of minimums is maximized
- Find the maximum number of composite summands of a number
- Maximum number of strings that can be formed with given zeros and ones
- Minimum and Maximum values of an expression with * and +
- How to print maximum number of A's using given four keys
- Recursively break a number in 3 parts to get maximum sum
- Maximum sum of a path in a Right Number Triangle
- Maximum number of trailing zeros in the product of the subsets of size k
- Minimum number greater than the maximum of array which cannot be formed using the numbers in the array
- Paths with maximum number of 'a' from (1, 1) to (X, Y) vertically or horizontally
- Possible cuts of a number such that maximum parts are divisible by 3
- Maximum number of given operations to remove the entire string
- Number of subsequences of maximum length K containing no repeated elements
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.
